@probemesh/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2026 @@
+import { IncomingMessage, ServerResponse, Server } from 'node:http';
+import { PaymentPayload, PaymentRequirements, PaymentRequired, VerifyResponse, SettleResponse, ResourceInfo, Network } from '@x402/core/types';
+import { ExactEvmSchemeOptions } from '@x402/evm/exact/client';
+import { ClientEvmSigner } from '@x402/evm';
+import { PrivateKeyAccount } from 'viem';
+
+type CallStatus = "completed" | "failed";
+type ProviderMode = "local" | "hosted" | "network" | string;
+type ReceiptType = "payment_proof" | "settlement_confirmation" | "provider_delivery" | "provider_response_evidence" | "authorization_decision";
+type ReceiptStatus = "recorded" | "pending" | "missing";
+type PaymentStatus = "not_attempted" | "authorized" | "failed";
+type SettlementStatus = "not_attempted" | "settled" | "failed";
+type DeliveryStatus = "not_attempted" | "delivered" | "failed" | "missing";
+type ProbeMeshErrorCode = "unauthorized" | "invalid_request" | "budget_exceeded" | "provider_unavailable" | "retry_not_available" | "payment_failed" | "receipt_missing" | "timeout_after_payment" | "charged_but_no_result" | "provider_timeout" | "invalid_provider_response";
+type ProbeMeshTimelineEventType = "call.requested" | "provider.selected" | "provider.attempted" | "payment.attempted" | "receipt.recorded" | "retry.requested" | "retry.blocked" | "call.completed" | "call.failed";
+type ProbeMeshRetrySafetyReason = "completed" | "not_retryable" | "money_may_have_moved" | "payment_failed_no_charge" | "no_payment_attempted" | "unknown_payment_state";
+interface ProviderCatalogPolicyBundleAttestation {
+    schemaVersion: "probemesh.catalog-policy-bundle.v1";
+    bundleId: string;
+    status: "passed" | "failed";
+    hashAlgorithm: "sha256";
+    bundleHash: string;
+    catalogHash: string;
+    catalogPolicyHash: string;
+    adapterInventoryHash: string;
+    queriesHash: string;
+    evaluationHash: string;
+    runtimeVerified: boolean;
+    covered: boolean;
+    capability?: string;
+    queryIndex?: number;
+    reason?: string;
+}
+interface ProviderPaymentOption {
+    id: string;
+    protocolMode: string;
+    capabilities?: string[];
+    pricing?: ProbeMeshPricing | Record<string, ProbeMeshPricing>;
+    receiptTypes?: ReceiptType[];
+    metadata?: Record<string, unknown>;
+}
+interface ProbeMeshPaymentPreferences {
+    allowedProtocols?: string[];
+    preferredProtocols?: string[];
+    blockedProtocols?: string[];
+    allowedPaymentOptions?: string[];
+    preferredPaymentOptions?: string[];
+    blockedPaymentOptions?: string[];
+    requiredReceiptTypes?: ReceiptType[];
+}
+type ProbeMeshPaymentStrategyMode = "provider_order" | "lowest_cost" | "preferred_protocol" | "receipt_coverage";
+interface ProbeMeshPaymentStrategy {
+    mode: ProbeMeshPaymentStrategyMode;
+    preferredReceiptTypes?: ReceiptType[];
+}
+interface ProbeMeshPaymentSelection {
+    providerId: string;
+    optionId: string;
+    protocolMode: string;
+    cost?: Cost;
+    receiptTypes: ReceiptType[];
+    score?: number;
+    scoreReasons?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface ProbeMeshConstraints {
+    maxCostUsd?: number;
+    maxLatencyMs?: number;
+    requireReceipt?: boolean;
+    onUncertain?: "allow" | "warn" | "review" | "block";
+    minConfidence?: number;
+}
+interface ProviderPreferences {
+    allowedProviders?: string[];
+    blockedProviders?: string[];
+}
+interface ProbeMeshFeedback {
+    outcome?: "useful" | "not_useful" | "incorrect";
+    note?: string;
+}
+interface ProbeMeshCallRequest<Input = unknown> {
+    capability: string;
+    input: Input;
+    constraints?: ProbeMeshConstraints;
+    providerPreferences?: ProviderPreferences;
+    paymentPreferences?: ProbeMeshPaymentPreferences;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    idempotencyKey?: string;
+    feedback?: ProbeMeshFeedback;
+}
+interface Cost {
+    amountUsd: number;
+    currency?: "USD" | string;
+    unit?: string;
+}
+interface ReceiptRef {
+    type: ReceiptType;
+    provider: string;
+    status: ReceiptStatus;
+    ref: string;
+    timestamp: string;
+}
+interface ProbeMeshCallSafety {
+    paymentAttemptId?: string;
+    paymentStatus: PaymentStatus;
+    settlementStatus: SettlementStatus;
+    deliveryStatus: DeliveryStatus;
+    moneyMayHaveMoved: boolean;
+}
+interface ProbeMeshRetryRequest {
+    callId: string;
+    idempotencyKey?: string;
+}
+interface ProbeMeshAttemptMetadata {
+    originalCallId: string;
+    attemptId: string;
+    attemptNumber: number;
+    isRetry: boolean;
+    previousAttemptId?: string;
+}
+interface ProbeMeshTimelineEvent {
+    type: ProbeMeshTimelineEventType;
+    routeId: string;
+    timestamp: string;
+    callId?: string;
+    capability?: string;
+    provider?: string;
+    status?: CallStatus;
+    errorCode?: ProbeMeshErrorCode;
+    safety?: ProbeMeshCallSafety;
+    receiptRef?: ReceiptRef;
+    attempt?: ProbeMeshAttemptMetadata;
+    attestation?: ProviderCatalogPolicyBundleAttestation;
+}
+interface ProbeMeshCallTimeline {
+    routeId: string;
+    events: ProbeMeshTimelineEvent[];
+}
+interface ProbeMeshRetrySafety {
+    retryable: boolean;
+    safeToAutoRetry: boolean;
+    reason: ProbeMeshRetrySafetyReason;
+}
+type ProbeMeshRouteDecisionReason = "eligible" | "selected" | "fallback_after_failure" | "skipped_capability_mismatch" | "skipped_allowed_provider" | "skipped_blocked_provider" | "skipped_budget_exceeded" | "skipped_unhealthy_provider" | "skipped_catalog_policy" | "skipped_catalog_adapter_missing" | "skipped_policy_bundle_uncovered" | "skipped_payment_preferences" | "stopped_completed" | "stopped_payment_evidence" | "stopped_not_retryable" | "no_eligible_provider";
+type ProbeMeshProviderHealthStatus = "healthy" | "unhealthy" | "unknown";
+type ProbeMeshProviderRouteAttemptStatus = "considered" | "skipped" | "attempted" | "failed" | "succeeded";
+interface ProbeMeshProviderRouteAttempt {
+    providerId: string;
+    status: ProbeMeshProviderRouteAttemptStatus;
+    reason: ProbeMeshRouteDecisionReason;
+    errorCode?: ProbeMeshErrorCode;
+    cost?: Cost;
+    budgetExceeded?: boolean;
+    paymentEvidence?: boolean;
+    catalogArtifactId?: string;
+    catalogStatus?: "ready" | "rejected";
+    catalogMatchReasons?: string[];
+    catalogPolicyReason?: string;
+    healthStatus?: ProbeMeshProviderHealthStatus;
+    lastFailureAt?: string;
+    cooldownUntil?: string;
+    consecutiveFailures?: number;
+    paymentSelection?: ProbeMeshPaymentSelection;
+    paymentOptionReason?: string;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    paymentOptionScore?: number;
+    paymentOptionScoreReasons?: string[];
+    message?: string;
+    attestation?: ProviderCatalogPolicyBundleAttestation;
+}
+interface ProbeMeshRouteExplanation {
+    consideredProviders: string[];
+    selectedProviderId?: string;
+    fallbackUsed: boolean;
+    fallbackCount: number;
+    stopReason: ProbeMeshRouteDecisionReason;
+    attempts: ProbeMeshProviderRouteAttempt[];
+}
+interface ProviderMetadata {
+    id: string;
+    mode: ProviderMode;
+    displayName?: string;
+}
+interface ProbeMeshCallResponse<Data = unknown> {
+    callId: string;
+    capability: string;
+    data: Data;
+    provider: ProviderMetadata;
+    cost?: Cost;
+    latencyMs: number;
+    receiptRefs: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+    timeline?: ProbeMeshCallTimeline;
+    retrySafety?: ProbeMeshRetrySafety;
+    attempt?: ProbeMeshAttemptMetadata;
+    route?: ProbeMeshRouteMetadata;
+    status: "completed";
+}
+interface ProbeMeshRouteMetadata {
+    routeId: string;
+    mode: "hosted" | "local" | "network" | string;
+    selectedProviderId?: string;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    paymentSelection?: ProbeMeshPaymentSelection;
+    explanation?: ProbeMeshRouteExplanation;
+    attestation?: ProviderCatalogPolicyBundleAttestation;
+}
+interface ProbeMeshPricing {
+    unit: "call" | string;
+    amountUsd: number;
+    currency?: "USD" | string;
+}
+interface ProbeMeshAdapterCallRequest<Input = unknown> extends ProbeMeshCallRequest<Input> {
+    callId: string;
+}
+interface ProbeMeshAdapterContext {
+    callId: string;
+    startedAt: Date;
+    signal: AbortSignal;
+    constraints?: ProbeMeshConstraints;
+    providerPreferences?: ProviderPreferences;
+    paymentPreferences?: ProbeMeshPaymentPreferences;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    paymentSelection?: ProbeMeshPaymentSelection;
+}
+interface ProbeMeshAdapterCallResult<Data = unknown> {
+    data: Data;
+    cost?: Cost;
+    receiptRefs?: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+    provider?: Partial<ProviderMetadata>;
+}
+interface ProbeMeshAdapter<Input = unknown, Data = unknown> {
+    id: string;
+    displayName?: string;
+    mode?: ProviderMode;
+    capabilities: string[];
+    pricing?: ProbeMeshPricing | Record<string, ProbeMeshPricing>;
+    paymentOptions?: ProviderPaymentOption[];
+    call(request: ProbeMeshAdapterCallRequest<Input>, context: ProbeMeshAdapterContext): ProbeMeshAdapterCallResult<Data> | Promise<ProbeMeshAdapterCallResult<Data>>;
+}
+interface ProbeMeshClient {
+    call<Input = unknown, Data = unknown>(request: ProbeMeshCallRequest<Input>): Promise<ProbeMeshCallResponse<Data>>;
+    retry<Data = unknown>(request: ProbeMeshRetryRequest): Promise<ProbeMeshCallResponse<Data>>;
+}
+interface ProbeMeshHostedClientOptions {
+    baseUrl: string;
+    apiKey?: string;
+}
+interface ProbeMeshClientOptions {
+    adapters?: ProbeMeshAdapter[];
+    hosted?: ProbeMeshHostedClientOptions;
+}
+interface ProbeMeshLocalClientOptions {
+    adapters: ProbeMeshAdapter[];
+}
+
+interface PriceLookupInput {
+    symbol: string;
+    currency?: string;
+}
+interface PriceLookupData {
+    symbol: string;
+    currency: string;
+    price: number;
+    asOf: string;
+    source: string;
+}
+interface PriceLookupAdapterOptions {
+    id?: string;
+    displayName?: string;
+    prices?: Record<string, number>;
+}
+declare function createPriceLookupAdapter(options?: PriceLookupAdapterOptions): ProbeMeshAdapter<PriceLookupInput, PriceLookupData>;
+
+declare function createProbeMesh(options: ProbeMeshClientOptions): ProbeMeshClient;
+
+type ProviderProtocolMode = "direct-api" | "mock" | "mcp" | "x402" | "api-key" | (string & {});
+interface JsonSchemaLike {
+    type?: string;
+    properties?: Record<string, JsonSchemaLike>;
+    required?: string[];
+    items?: JsonSchemaLike;
+    enum?: unknown[];
+    description?: string;
+    [key: string]: unknown;
+}
+interface ProviderReceiptSupport {
+    payment: boolean;
+    delivery: boolean;
+    responseEvidence: boolean;
+}
+interface ProviderLimits {
+    maxRequestsPerMinute?: number;
+    [key: string]: unknown;
+}
+interface ProviderManifest {
+    id: string;
+    displayName: string;
+    capabilities: string[];
+    protocolMode: ProviderProtocolMode;
+    paymentOptions?: ProviderPaymentOption[];
+    pricing: ProbeMeshPricing | Record<string, ProbeMeshPricing>;
+    inputSchema: JsonSchemaLike | Record<string, JsonSchemaLike>;
+    outputSchema: JsonSchemaLike | Record<string, JsonSchemaLike>;
+    receipts: ProviderReceiptSupport;
+    limits?: ProviderLimits;
+}
+interface ProviderManifestValidationError {
+    path: string;
+    message: string;
+}
+interface ProviderManifestValidationResult {
+    valid: boolean;
+    errors: ProviderManifestValidationError[];
+}
+
+interface ProviderProtocolPreparation {
+    mode: ProviderProtocolMode;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    receiptRefs?: ReceiptRef[];
+    safety?: Partial<ProbeMeshCallSafety>;
+}
+interface ProviderProtocolSettlement {
+    mode: ProviderProtocolMode;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    receiptRefs?: ReceiptRef[];
+    safety?: Partial<ProbeMeshCallSafety>;
+}
+interface ProviderProtocolExecution {
+    mode: ProviderProtocolMode;
+    preparation?: ProviderProtocolPreparation;
+    settlement?: ProviderProtocolSettlement;
+    receiptRefs: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+}
+interface ProviderProtocolPrepareInput<Input = unknown> {
+    manifest: ProviderManifest;
+    request: ProbeMeshAdapterCallRequest<Input>;
+    context: ProbeMeshAdapterContext;
+}
+interface ProviderProtocolSettleInput<Input = unknown, Data = unknown> {
+    manifest: ProviderManifest;
+    request: ProbeMeshAdapterCallRequest<Input>;
+    context: ProbeMeshAdapterContext;
+    result: ProbeMeshAdapterCallResult<Data>;
+    preparation?: ProviderProtocolPreparation;
+}
+interface ProviderProtocolAdapter {
+    mode: ProviderProtocolMode;
+    prepare?<Input = unknown>(input: ProviderProtocolPrepareInput<Input>): ProviderProtocolPreparation | Promise<ProviderProtocolPreparation>;
+    settle?<Input = unknown, Data = unknown>(input: ProviderProtocolSettleInput<Input, Data>): ProviderProtocolSettlement | Promise<ProviderProtocolSettlement>;
+}
+interface ProviderManifestHandlerContext extends ProbeMeshAdapterContext {
+    protocol?: ProviderProtocolExecution;
+}
+interface CreateAdapterFromManifestOptions {
+    protocolAdapters?: ProviderProtocolAdapter[];
+}
+
+interface MockPaymentProtocolOptions {
+    mode?: ProviderProtocolMode;
+    failPrepare?: boolean;
+    failPrepareOnce?: boolean;
+    failSettle?: boolean;
+    omitDeliveryReceipt?: boolean;
+    paymentAttemptId?: string;
+}
+declare function createMockPaymentProtocol(options?: MockPaymentProtocolOptions): ProviderProtocolAdapter;
+
+type PaidPriceLookupFailureMode = "none" | "timeout_after_payment" | "missing_delivery_receipt";
+interface PaidPriceLookupProviderOptions {
+    id?: string;
+    displayName?: string;
+    amountUsd?: number;
+    prices?: Record<string, number>;
+    mockPayment?: MockPaymentProtocolOptions;
+    failureMode?: PaidPriceLookupFailureMode;
+}
+interface PaidPriceLookupData {
+    symbol: string;
+    currency: string;
+    price: number;
+    asOf: string;
+    source: string;
+    protocolMode?: string;
+    paymentAuthorized: boolean;
+}
+declare function createPaidPriceLookupProvider(options?: PaidPriceLookupProviderOptions): ProbeMeshAdapter;
+
+interface ProbeMeshErrorOptions {
+    code: ProbeMeshErrorCode;
+    message: string;
+    capability?: string;
+    provider?: string;
+    callId?: string;
+    receiptRefs?: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+    timeline?: ProbeMeshCallTimeline;
+    retrySafety?: ProbeMeshRetrySafety;
+    attempt?: ProbeMeshAttemptMetadata;
+    route?: ProbeMeshRouteMetadata;
+    cause?: unknown;
+}
+declare class ProbeMeshError extends Error {
+    readonly code: ProbeMeshErrorCode;
+    readonly status: CallStatus;
+    readonly capability?: string;
+    readonly provider?: string;
+    readonly callId?: string;
+    readonly receiptRefs?: ReceiptRef[];
+    readonly safety?: ProbeMeshCallSafety;
+    readonly timeline?: ProbeMeshCallTimeline;
+    readonly retrySafety?: ProbeMeshRetrySafety;
+    readonly attempt?: ProbeMeshAttemptMetadata;
+    readonly route?: ProbeMeshRouteMetadata;
+    readonly cause?: unknown;
+    constructor(options: ProbeMeshErrorOptions);
+    toJSON(): {
+        name: string;
+        code: ProbeMeshErrorCode;
+        message: string;
+        status: CallStatus;
+        capability: string | undefined;
+        provider: string | undefined;
+        callId: string | undefined;
+        receiptRefs: ReceiptRef[] | undefined;
+        safety: ProbeMeshCallSafety | undefined;
+        timeline: ProbeMeshCallTimeline | undefined;
+        retrySafety: ProbeMeshRetrySafety | undefined;
+        attempt: ProbeMeshAttemptMetadata | undefined;
+        route: ProbeMeshRouteMetadata | undefined;
+    };
+}
+declare function isProbeMeshError(error: unknown): error is ProbeMeshError;
+
+declare const PROBEMESH_CALL_AUDIT_ARTIFACT_SCHEMA_VERSION: "probemesh.call-audit.v1";
+type ProbeMeshCallAuditArtifactStatus = "completed" | "failed";
+type ProbeMeshCallAuditArtifactFormat = "json" | "markdown";
+interface ProbeMeshCallAuditArtifactOptions {
+    request: ProbeMeshCallRequest;
+    response?: ProbeMeshCallResponse;
+    error?: ProbeMeshError;
+    generatedAt?: string;
+    artifactId?: string;
+    forbiddenOutputValues?: string[];
+    timeline?: ProbeMeshCallTimeline;
+    retrySafety?: ProbeMeshRetrySafety;
+    attempt?: ProbeMeshAttemptMetadata;
+    route?: ProbeMeshRouteMetadata;
+}
+interface ProbeMeshCallAuditArtifactHashes {
+    request: string;
+    route: string;
+    timeline: string;
+    receipts: string;
+    safety: string;
+    retrySafety: string;
+    artifact: string;
+}
+interface ProbeMeshCallAuditArtifactReceiptSummary {
+    total: number;
+    types: string[];
+    providers: string[];
+    byType: Record<string, number>;
+    hasPaymentProof: boolean;
+    hasSettlementConfirmation: boolean;
+    hasProviderDelivery: boolean;
+}
+interface ProbeMeshCallAuditArtifactTimelineEvent {
+    type: ProbeMeshTimelineEventType;
+    timestamp: string;
+    provider?: string;
+    status?: CallStatus;
+    errorCode?: ProbeMeshErrorCode;
+    receiptType?: string;
+    attestationBundleId?: string;
+}
+interface ProbeMeshCallAuditArtifactTimelineSummary {
+    routeId?: string;
+    eventTypes: ProbeMeshTimelineEventType[];
+    events: ProbeMeshCallAuditArtifactTimelineEvent[];
+}
+interface ProbeMeshCallAuditArtifactCallSummary {
+    callId?: string;
+    capability: string;
+    status: ProbeMeshCallAuditArtifactStatus;
+    providerId?: string;
+    errorCode?: ProbeMeshErrorCode;
+    cost?: Cost;
+    latencyMs?: number;
+    attempt?: ProbeMeshAttemptMetadata;
+}
+interface ProbeMeshCallAuditArtifactRequestProof {
+    requestHash: string;
+    idempotencyKey?: string;
+}
+interface ProbeMeshCallAuditArtifactEvidence {
+    receiptSummary: ProbeMeshCallAuditArtifactReceiptSummary;
+    receiptRefs: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+    retrySafety?: ProbeMeshRetrySafety;
+    route?: ProbeMeshRouteMetadata;
+    timeline: ProbeMeshCallAuditArtifactTimelineSummary;
+}
+interface ProbeMeshCallAuditArtifact {
+    schemaVersion: typeof PROBEMESH_CALL_AUDIT_ARTIFACT_SCHEMA_VERSION;
+    artifactId: string;
+    generatedAt: string;
+    status: ProbeMeshCallAuditArtifactStatus;
+    hashAlgorithm: "sha256";
+    hashes: ProbeMeshCallAuditArtifactHashes;
+    call: ProbeMeshCallAuditArtifactCallSummary;
+    request: ProbeMeshCallAuditArtifactRequestProof;
+    evidence: ProbeMeshCallAuditArtifactEvidence;
+}
+interface ProbeMeshCallAuditArtifactValidationError {
+    path: string;
+    message: string;
+}
+interface ProbeMeshCallAuditArtifactValidationResult {
+    valid: boolean;
+    errors: ProbeMeshCallAuditArtifactValidationError[];
+}
+declare function createProbeMeshCallAuditArtifact(options: ProbeMeshCallAuditArtifactOptions): ProbeMeshCallAuditArtifact;
+declare function validateProbeMeshCallAuditArtifact(artifact: unknown): ProbeMeshCallAuditArtifactValidationResult;
+declare function assertProbeMeshCallAuditArtifact(artifact: unknown): asserts artifact is ProbeMeshCallAuditArtifact;
+declare function formatProbeMeshCallAuditArtifact(artifact: ProbeMeshCallAuditArtifact, options?: {
+    format?: ProbeMeshCallAuditArtifactFormat;
+}): string;
+
+type X402ProviderAcceptanceStatus = "passed" | "failed";
+interface X402ProviderAcceptanceCheck {
+    name: string;
+    status: X402ProviderAcceptanceStatus;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface X402ProviderAcceptanceOptions<Input = unknown> {
+    adapters: ProbeMeshAdapter[];
+    request: ProbeMeshCallRequest<Input>;
+    apiKey?: string;
+    expectedProviderId?: string;
+    requiredReceiptTypes?: ReceiptType[];
+    forbiddenOutputValues?: string[];
+}
+interface X402ProviderAcceptanceError {
+    name: "ProbeMeshError";
+    code: ProbeMeshErrorCode;
+    message: string;
+    status: "failed";
+    capability?: string;
+    provider?: string;
+    callId?: string;
+    receiptRefs?: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+    timeline?: ProbeMeshCallTimeline;
+    retrySafety?: ProbeMeshRetrySafety;
+    route?: ProbeMeshRouteMetadata;
+}
+interface X402ProviderAcceptanceResult<Data = unknown> {
+    status: X402ProviderAcceptanceStatus;
+    checks: X402ProviderAcceptanceCheck[];
+    response?: ProbeMeshCallResponse<Data>;
+    error?: X402ProviderAcceptanceError;
+    telemetryEvents: HostedTelemetryEvent[];
+    summary: X402ProviderAcceptanceSummary;
+}
+interface X402ProviderAcceptanceSummary {
+    status: X402ProviderAcceptanceStatus;
+    totalChecks: number;
+    passedChecks: number;
+    failedChecks: number;
+    failedCheckNames: string[];
+    callId?: string;
+    providerId?: string;
+    errorCode?: ProbeMeshErrorCode;
+    receiptTypes: ReceiptType[];
+    requiredReceiptTypes: ReceiptType[];
+    timelineEventTypes: ProbeMeshTimelineEventType[];
+    telemetryEventTypes: ProbeMeshTimelineEventType[];
+    safety?: ProbeMeshCallSafety;
+    retrySafety?: ProbeMeshRetrySafety;
+    route?: {
+        routeId?: string;
+        selectedProviderId?: string;
+        fallbackUsed?: boolean;
+        fallbackCount?: number;
+        stopReason?: ProbeMeshRouteDecisionReason;
+    };
+}
+type X402ProviderAcceptanceGateStatus = "accepted" | "rejected";
+interface X402ProviderAcceptanceGateOptions {
+    requiredCheckNames?: string[];
+}
+interface X402ProviderAcceptanceGate {
+    accepted: boolean;
+    status: X402ProviderAcceptanceGateStatus;
+    requiredCheckNames: string[];
+    failedRequiredCheckNames: string[];
+    reasons: string[];
+}
+interface X402ProviderAcceptanceReportOptions {
+    gate?: X402ProviderAcceptanceGateOptions;
+    forbiddenOutputValues?: string[];
+    title?: string;
+}
+type X402ProviderAcceptanceReportFormat = "json" | "markdown";
+interface X402ProviderAcceptanceReport {
+    title: string;
+    status: X402ProviderAcceptanceStatus;
+    gate: X402ProviderAcceptanceGate;
+    summary: X402ProviderAcceptanceSummary;
+    checks: X402ProviderAcceptanceCheck[];
+    receipts: {
+        total: number;
+        types: ReceiptType[];
+        providers: string[];
+        byType: Partial<Record<ReceiptType, number>>;
+        hasPaymentProof: boolean;
+        hasSettlementConfirmation: boolean;
+        hasProviderDelivery: boolean;
+    };
+    route?: X402ProviderAcceptanceSummary["route"];
+    timelineEventTypes: ProbeMeshTimelineEventType[];
+    telemetryEventTypes: ProbeMeshTimelineEventType[];
+    safety?: ProbeMeshCallSafety;
+    retrySafety?: ProbeMeshRetrySafety;
+    error?: X402ProviderAcceptanceError;
+}
+declare function runX402ProviderAcceptance<Input = unknown, Data = unknown>(options: X402ProviderAcceptanceOptions<Input>): Promise<X402ProviderAcceptanceResult<Data>>;
+declare function summarizeX402AcceptanceResult(result: X402ProviderAcceptanceResult): X402ProviderAcceptanceSummary;
+declare function evaluateX402ProviderAcceptanceGate(result: X402ProviderAcceptanceResult, options?: X402ProviderAcceptanceGateOptions): X402ProviderAcceptanceGate;
+declare function createX402ProviderAcceptanceReport(result: X402ProviderAcceptanceResult, options?: X402ProviderAcceptanceReportOptions): X402ProviderAcceptanceReport;
+declare function formatX402ProviderAcceptanceReport(report: X402ProviderAcceptanceReport, options?: {
+    format?: X402ProviderAcceptanceReportFormat;
+}): string;
+
+declare const PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION: "probemesh.provider-catalog.v1";
+type ProviderCatalogArtifactStatus = "ready" | "rejected";
+type ProviderCatalogArtifactFormat = "json" | "markdown";
+interface ProviderCatalogArtifactOptions {
+    manifest: ProviderManifest;
+    acceptanceReport: X402ProviderAcceptanceReport;
+    generatedAt?: string;
+    artifactId?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderCatalogArtifact {
+    schemaVersion: typeof PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION;
+    artifactId: string;
+    generatedAt: string;
+    status: ProviderCatalogArtifactStatus;
+    provider: ProviderManifest;
+    acceptance: {
+        title: string;
+        status: X402ProviderAcceptanceStatus;
+        gate: X402ProviderAcceptanceGate;
+        failedChecks: string[];
+        receipts: X402ProviderAcceptanceReport["receipts"];
+        safety?: ProbeMeshCallSafety;
+        retrySafety?: ProbeMeshRetrySafety;
+        route?: X402ProviderAcceptanceSummary["route"];
+        timelineEventTypes: ProbeMeshTimelineEventType[];
+        telemetryEventTypes: ProbeMeshTimelineEventType[];
+        errorCode?: string;
+    };
+}
+interface ProviderCatalogArtifactValidationError {
+    path: string;
+    message: string;
+}
+interface ProviderCatalogArtifactValidationResult {
+    valid: boolean;
+    errors: ProviderCatalogArtifactValidationError[];
+}
+declare function createProviderCatalogArtifact(options: ProviderCatalogArtifactOptions): ProviderCatalogArtifact;
+declare function formatProviderCatalogArtifact(artifact: ProviderCatalogArtifact, options?: {
+    format?: ProviderCatalogArtifactFormat;
+}): string;
+declare function validateProviderCatalogArtifact(artifact: unknown): ProviderCatalogArtifactValidationResult;
+declare function assertProviderCatalogArtifact(artifact: unknown): asserts artifact is ProviderCatalogArtifact;
+
+declare const PROVIDER_CATALOG_SCHEMA_VERSION: "probemesh.provider-catalog.index.v1";
+interface ProviderCatalogOptions {
+    artifacts: ProviderCatalogArtifact[];
+    generatedAt?: string;
+}
+interface ProviderCatalog {
+    schemaVersion: typeof PROVIDER_CATALOG_SCHEMA_VERSION;
+    generatedAt: string;
+    entries: ProviderCatalogEntry[];
+}
+interface ProviderCatalogEntry {
+    artifactId: string;
+    generatedAt: string;
+    status: ProviderCatalogArtifactStatus;
+    provider: {
+        id: string;
+        displayName: string;
+        capabilities: string[];
+        protocolMode: ProviderProtocolMode;
+        paymentOptions?: ProviderPaymentOption[];
+        pricing: ProviderManifest["pricing"];
+        receipts: ProviderReceiptSupport;
+        limits?: ProviderLimits;
+    };
+    acceptance: {
+        gate: X402ProviderAcceptanceGate;
+        failedChecks: string[];
+        receipts: ProviderCatalogArtifact["acceptance"]["receipts"];
+        safety?: ProbeMeshCallSafety;
+        retrySafety?: ProbeMeshRetrySafety;
+        route?: ProviderCatalogArtifact["acceptance"]["route"];
+        timelineEventTypes: ProbeMeshTimelineEventType[];
+        telemetryEventTypes: ProbeMeshTimelineEventType[];
+        errorCode?: string;
+    };
+}
+interface ProviderCatalogQuery {
+    capability: string;
+    protocolMode?: ProviderProtocolMode;
+    paymentPreferences?: ProbeMeshPaymentPreferences;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    maxCostUsd?: number;
+    requiredReceiptTypes?: ReceiptType[];
+    providerIds?: string[];
+    blockedProviderIds?: string[];
+    status?: ProviderCatalogArtifactStatus;
+}
+interface ProviderCatalogMatch {
+    entry: ProviderCatalogEntry;
+    providerId: string;
+    capability: string;
+    status: ProviderCatalogArtifactStatus;
+    cost?: Cost;
+    paymentSelection?: ProbeMeshPaymentSelection;
+    reasons: string[];
+}
+interface ProviderCatalogSummary {
+    schemaVersion: typeof PROVIDER_CATALOG_SCHEMA_VERSION;
+    generatedAt: string;
+    totalEntries: number;
+    readyEntries: number;
+    rejectedEntries: number;
+    providers: string[];
+    capabilities: string[];
+    protocolModes: string[];
+}
+interface ProviderCatalogValidationError {
+    path: string;
+    message: string;
+}
+interface ProviderCatalogValidationResult {
+    valid: boolean;
+    errors: ProviderCatalogValidationError[];
+}
+declare function validateProviderCatalog(catalog: unknown): ProviderCatalogValidationResult;
+declare function assertProviderCatalog(catalog: unknown): asserts catalog is ProviderCatalog;
+declare function parseProviderCatalogArtifactJson(json: string): ProviderCatalogArtifact;
+declare function createProviderCatalog(options: ProviderCatalogOptions): ProviderCatalog;
+declare function findProviderCatalogMatches(catalog: ProviderCatalog, query: ProviderCatalogQuery): ProviderCatalogMatch[];
+declare function summarizeProviderCatalog(catalog: ProviderCatalog): ProviderCatalogSummary;
+
+type ProviderCatalogPolicyEvaluationStatus = "passed" | "failed";
+type ProviderCatalogPolicyCheckStatus = "passed" | "failed";
+type ProviderCatalogPolicyReportFormat = "json" | "markdown";
+interface ProviderCatalogPolicyAdapterInventoryEntry {
+    id: string;
+    capabilities: string[];
+    pricing?: ProbeMeshPricing | Record<string, ProbeMeshPricing>;
+    paymentOptions?: ProviderPaymentOption[];
+}
+type ProviderCatalogPolicyAdapterInventory = ProviderCatalogPolicyAdapterInventoryEntry[];
+interface ProviderCatalogPolicyOptions {
+    enabled?: boolean;
+    status?: ProviderCatalogArtifactStatus;
+    protocolMode?: ProviderProtocolMode;
+    paymentPreferences?: ProbeMeshPaymentPreferences;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    maxCostUsd?: number;
+    requiredReceiptTypes?: ReceiptType[];
+    providerIds?: string[];
+    blockedProviderIds?: string[];
+}
+interface ProviderCatalogPolicyExpectedQuery extends ProviderCatalogPolicyOptions {
+    capability: string;
+    minMatches?: number;
+}
+interface ProviderCatalogPolicyEvaluationOptions {
+    catalog: ProviderCatalog;
+    catalogPolicy?: ProviderCatalogPolicyOptions;
+    adapterInventory: ProviderCatalogPolicyAdapterInventory;
+    queries: ProviderCatalogPolicyExpectedQuery[];
+}
+interface ProviderCatalogPolicyCheck {
+    name: string;
+    status: ProviderCatalogPolicyCheckStatus;
+    message: string;
+    capability?: string;
+    providerId?: string;
+}
+interface ProviderCatalogPolicySkippedProvider {
+    providerId: string;
+    capability: string;
+    reasons: string[];
+    catalogArtifactId?: string;
+    catalogStatus?: ProviderCatalogArtifactStatus;
+    inventoryOnly?: boolean;
+}
+interface ProviderCatalogPolicyMissingAdapterMatch {
+    providerId: string;
+    capability: string;
+    catalogArtifactId: string;
+    catalogStatus: ProviderCatalogArtifactStatus;
+    reasons: string[];
+}
+interface ProviderCatalogPolicyQueryResult {
+    query: ProviderCatalogPolicyExpectedQuery;
+    matches: ProviderCatalogMatch[];
+    routeableMatches: ProviderCatalogMatch[];
+    missingAdapterMatches: ProviderCatalogPolicyMissingAdapterMatch[];
+    skippedProviders: ProviderCatalogPolicySkippedProvider[];
+}
+interface ProviderCatalogPolicyEvaluationResult {
+    status: ProviderCatalogPolicyEvaluationStatus;
+    checks: ProviderCatalogPolicyCheck[];
+    summary: ProviderCatalogSummary & {
+        totalQueries: number;
+        passedChecks: number;
+        failedChecks: number;
+        routeableMatches: number;
+        missingAdapterMatches: number;
+    };
+    queryResults: ProviderCatalogPolicyQueryResult[];
+}
+interface ProviderCatalogPolicyReportOptions {
+    title?: string;
+    generatedAt?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderCatalogPolicyReport {
+    title: string;
+    generatedAt: string;
+    status: ProviderCatalogPolicyEvaluationStatus;
+    summary: ProviderCatalogPolicyEvaluationResult["summary"];
+    checks: ProviderCatalogPolicyCheck[];
+    queryResults: ProviderCatalogPolicyQueryResult[];
+}
+declare function evaluateProviderCatalogPolicy(options: ProviderCatalogPolicyEvaluationOptions): ProviderCatalogPolicyEvaluationResult;
+declare function createProviderCatalogPolicyReport(result: ProviderCatalogPolicyEvaluationResult, options?: ProviderCatalogPolicyReportOptions): ProviderCatalogPolicyReport;
+declare function formatProviderCatalogPolicyReport(report: ProviderCatalogPolicyReport, options?: {
+    format?: ProviderCatalogPolicyReportFormat;
+}): string;
+
+declare const PROVIDER_CATALOG_POLICY_BUNDLE_SCHEMA_VERSION: "probemesh.catalog-policy-bundle.v1";
+type ProviderCatalogPolicyBundleStatus = "passed" | "failed";
+type ProviderCatalogPolicyBundleFormat = "json" | "markdown";
+interface ProviderCatalogPolicyBundleOptions {
+    catalog: ProviderCatalog;
+    catalogPolicy?: ProviderCatalogPolicyOptions;
+    adapterInventory: ProviderCatalogPolicyAdapterInventory;
+    queries: ProviderCatalogPolicyExpectedQuery[];
+    evaluation?: ProviderCatalogPolicyEvaluationResult;
+    generatedAt?: string;
+    bundleId?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderCatalogPolicyBundleHashes {
+    catalog: string;
+    catalogPolicy: string;
+    adapterInventory: string;
+    queries: string;
+    evaluation: string;
+    bundle: string;
+}
+interface ProviderCatalogPolicyBundleQueryCoverage {
+    capability: string;
+    minMatches: number;
+    matches: number;
+    routeableMatches: number;
+    missingAdapterMatches: number;
+    providerIds: string[];
+}
+interface ProviderCatalogPolicyBundle {
+    schemaVersion: typeof PROVIDER_CATALOG_POLICY_BUNDLE_SCHEMA_VERSION;
+    bundleId: string;
+    generatedAt: string;
+    status: ProviderCatalogPolicyBundleStatus;
+    hashAlgorithm: "sha256";
+    hashes: ProviderCatalogPolicyBundleHashes;
+    catalogSummary: ProviderCatalogSummary;
+    evaluationSummary: ProviderCatalogPolicyEvaluationResult["summary"];
+    queryCoverage: ProviderCatalogPolicyBundleQueryCoverage[];
+    checks: ProviderCatalogPolicyCheck[];
+    failedChecks: string[];
+    queries: ProviderCatalogPolicyExpectedQuery[];
+}
+interface ProviderCatalogPolicyBundleValidationError {
+    path: string;
+    message: string;
+}
+interface ProviderCatalogPolicyBundleValidationResult {
+    valid: boolean;
+    errors: ProviderCatalogPolicyBundleValidationError[];
+}
+interface ProviderCatalogPolicyBundleRuntimeVerificationOptions {
+    bundle: ProviderCatalogPolicyBundle;
+    catalog: ProviderCatalog;
+    catalogPolicy?: ProviderCatalogPolicyOptions;
+    adapterInventory: ProviderCatalogPolicyAdapterInventory;
+    queries?: ProviderCatalogPolicyExpectedQuery[];
+    capability?: string;
+}
+interface ProviderCatalogPolicyBundleRuntimeVerificationResult {
+    valid: boolean;
+    attestation: ProviderCatalogPolicyBundleAttestation;
+    errors: ProviderCatalogPolicyBundleValidationError[];
+    coveredQuery?: ProviderCatalogPolicyExpectedQuery;
+}
+declare function createProviderCatalogPolicyBundle(options: ProviderCatalogPolicyBundleOptions): ProviderCatalogPolicyBundle;
+declare function validateProviderCatalogPolicyBundle(bundle: unknown): ProviderCatalogPolicyBundleValidationResult;
+declare function assertProviderCatalogPolicyBundle(bundle: unknown): asserts bundle is ProviderCatalogPolicyBundle;
+declare function formatProviderCatalogPolicyBundle(bundle: ProviderCatalogPolicyBundle, options?: {
+    format?: ProviderCatalogPolicyBundleFormat;
+}): string;
+declare function verifyProviderCatalogPolicyBundleRuntime(options: ProviderCatalogPolicyBundleRuntimeVerificationOptions): ProviderCatalogPolicyBundleRuntimeVerificationResult;
+
+type HostedTelemetryEventType = ProbeMeshTimelineEventType;
+interface HostedTelemetryEvent extends ProbeMeshTimelineEvent {
+}
+interface HostedProviderHealthOptions {
+    enabled?: boolean;
+    cooldownMs?: number;
+}
+interface HostedProviderCatalogPolicyOptions {
+    catalog: ProviderCatalog;
+    bundle?: ProviderCatalogPolicyBundle;
+    enabled?: boolean;
+    status?: ProviderCatalogArtifactStatus;
+    protocolMode?: ProviderProtocolMode;
+    paymentPreferences?: ProbeMeshPaymentPreferences;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    maxCostUsd?: number;
+    requiredReceiptTypes?: ReceiptType[];
+    providerIds?: string[];
+    blockedProviderIds?: string[];
+}
+interface HostedAuditArtifactOptions {
+    enabled?: boolean;
+    onArtifact?: (artifact: ProbeMeshCallAuditArtifact) => void | Promise<void>;
+}
+interface HostedRouterOptions {
+    adapters: ProbeMeshAdapter[];
+    apiKeys?: string[];
+    providerHealth?: HostedProviderHealthOptions;
+    catalogPolicy?: HostedProviderCatalogPolicyOptions;
+    auditArtifacts?: HostedAuditArtifactOptions;
+    onTelemetryEvent?: (event: HostedTelemetryEvent) => void;
+}
+interface HostedRouter {
+    handle(request: IncomingMessage, response: ServerResponse): Promise<void>;
+}
+interface StartHostedRouterOptions extends HostedRouterOptions {
+    port: number;
+    host?: string;
+}
+interface StartedHostedRouter {
+    server: Server;
+    url: string;
+    close(): Promise<void>;
+}
+declare function createHostedRouter(options: HostedRouterOptions): HostedRouter;
+declare function startHostedRouter(options: StartHostedRouterOptions): Promise<StartedHostedRouter>;
+
+declare const PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION: "probemesh.audit-trail.v1";
+type ProbeMeshAuditTrailBundleStatus = "complete" | "incomplete";
+type ProbeMeshAuditTrailBundleFormat = "json" | "markdown";
+interface ProbeMeshAuditTrailBundleOptions {
+    artifacts: ProbeMeshCallAuditArtifact[];
+    generatedAt?: string;
+    bundleId?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProbeMeshAuditTrailBundleSummary {
+    totalCalls: number;
+    completedCalls: number;
+    failedCalls: number;
+    providers: string[];
+    capabilities: string[];
+    receiptTypes: string[];
+    policyBundleIds: string[];
+    unsafePaymentEvidenceCalls: number;
+    retrySafeFailures: number;
+    uncoveredPolicyFailures: number;
+}
+interface ProbeMeshAuditTrailBundleHashes {
+    artifacts: string;
+    summary: string;
+    bundle: string;
+}
+interface ProbeMeshAuditTrailBundle {
+    schemaVersion: typeof PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION;
+    bundleId: string;
+    generatedAt: string;
+    status: ProbeMeshAuditTrailBundleStatus;
+    hashAlgorithm: "sha256";
+    hashes: ProbeMeshAuditTrailBundleHashes;
+    summary: ProbeMeshAuditTrailBundleSummary;
+    artifacts: ProbeMeshCallAuditArtifact[];
+}
+interface ProbeMeshAuditTrailBundleValidationError {
+    path: string;
+    message: string;
+}
+interface ProbeMeshAuditTrailBundleValidationResult {
+    valid: boolean;
+    errors: ProbeMeshAuditTrailBundleValidationError[];
+}
+interface ProbeMeshAuditTrailCollector {
+    onArtifact(artifact: ProbeMeshCallAuditArtifact): void;
+    getArtifacts(): ProbeMeshCallAuditArtifact[];
+    clear(): void;
+    createBundle(options?: Omit<ProbeMeshAuditTrailBundleOptions, "artifacts">): ProbeMeshAuditTrailBundle;
+}
+declare function createProbeMeshAuditTrailCollector(): ProbeMeshAuditTrailCollector;
+declare function createProbeMeshAuditTrailBundle(options: ProbeMeshAuditTrailBundleOptions): ProbeMeshAuditTrailBundle;
+declare function summarizeProbeMeshAuditTrailBundle(bundleOrArtifacts: ProbeMeshAuditTrailBundle | ProbeMeshCallAuditArtifact[]): ProbeMeshAuditTrailBundleSummary;
+declare function validateProbeMeshAuditTrailBundle(bundle: unknown): ProbeMeshAuditTrailBundleValidationResult;
+declare function assertProbeMeshAuditTrailBundle(bundle: unknown): asserts bundle is ProbeMeshAuditTrailBundle;
+declare function formatProbeMeshAuditTrailBundle(bundle: ProbeMeshAuditTrailBundle, options?: {
+    format?: ProbeMeshAuditTrailBundleFormat;
+}): string;
+
+declare function validateProviderManifest(manifest: unknown): ProviderManifestValidationResult;
+declare function assertProviderManifest(manifest: unknown): asserts manifest is ProviderManifest;
+
+interface ProbeMeshAuditTrailExportCliSkip {
+    skip: true;
+    reason: string;
+    details?: unknown;
+}
+interface ProbeMeshAuditTrailExportCliOutputs {
+    json?: string;
+    markdown?: string;
+}
+interface ProbeMeshAuditTrailExportCliBundle extends Omit<ProbeMeshAuditTrailBundleOptions, "artifacts"> {
+    format?: ProbeMeshAuditTrailBundleFormat;
+}
+interface ProbeMeshAuditTrailExportCliConfig {
+    artifacts?: ProbeMeshCallAuditArtifact[];
+    artifactFiles?: string[];
+    bundle?: ProbeMeshAuditTrailExportCliBundle;
+    outputs?: ProbeMeshAuditTrailExportCliOutputs;
+}
+type ProbeMeshAuditTrailExportCliConfigExport = ProbeMeshAuditTrailExportCliConfig | ProbeMeshAuditTrailExportCliSkip;
+type ProbeMeshAuditTrailExportCliConfigFactory = (context: ProbeMeshAuditTrailExportCliConfigContext) => ProbeMeshAuditTrailExportCliConfigExport | Promise<ProbeMeshAuditTrailExportCliConfigExport>;
+interface ProbeMeshAuditTrailExportCliConfigContext {
+    argv: string[];
+    cwd: string;
+}
+interface ProbeMeshAuditTrailExportCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface ProbeMeshAuditTrailExportCliResult {
+    exitCode: 0 | 1 | 2;
+    skipped: boolean;
+    skip?: ProbeMeshAuditTrailExportCliSkip;
+    bundle?: ProbeMeshAuditTrailBundle;
+    stdout: string;
+    stderr?: string;
+    artifactPaths?: ProbeMeshAuditTrailExportCliOutputs;
+}
+declare function runProbeMeshAuditTrailExportCli(options?: ProbeMeshAuditTrailExportCliOptions): Promise<ProbeMeshAuditTrailExportCliResult>;
+
+interface ProviderCatalogPolicyCliSkip {
+    skip: true;
+    reason: string;
+    details?: unknown;
+}
+interface ProviderCatalogPolicyCliOutputs {
+    json?: string;
+    markdown?: string;
+    bundle?: string;
+}
+interface ProviderCatalogPolicyCliBundle {
+    bundleId?: string;
+    generatedAt?: string;
+}
+interface ProviderCatalogPolicyCliConfig {
+    catalog?: ProviderCatalog;
+    artifacts?: ProviderCatalogArtifact[];
+    catalogPolicy?: ProviderCatalogPolicyOptions;
+    adapterInventory: ProviderCatalogPolicyAdapterInventory;
+    queries: ProviderCatalogPolicyExpectedQuery[];
+    report?: ProviderCatalogPolicyReportOptions & {
+        format?: ProviderCatalogPolicyReportFormat;
+    };
+    bundle?: ProviderCatalogPolicyCliBundle;
+    outputs?: ProviderCatalogPolicyCliOutputs;
+}
+type ProviderCatalogPolicyCliConfigExport = ProviderCatalogPolicyCliConfig | ProviderCatalogPolicyCliSkip;
+type ProviderCatalogPolicyCliConfigFactory = (context: ProviderCatalogPolicyCliConfigContext) => ProviderCatalogPolicyCliConfigExport | Promise<ProviderCatalogPolicyCliConfigExport>;
+interface ProviderCatalogPolicyCliConfigContext {
+    argv: string[];
+    cwd: string;
+}
+interface ProviderCatalogPolicyCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface ProviderCatalogPolicyCliResult {
+    exitCode: 0 | 1 | 2;
+    skipped: boolean;
+    skip?: ProviderCatalogPolicyCliSkip;
+    evaluation?: ProviderCatalogPolicyEvaluationResult;
+    report?: ProviderCatalogPolicyReport;
+    bundle?: ProviderCatalogPolicyBundle;
+    stdout: string;
+    stderr?: string;
+    artifactPaths?: ProviderCatalogPolicyCliOutputs;
+}
+declare function runProviderCatalogPolicyCli(options?: ProviderCatalogPolicyCliOptions): Promise<ProviderCatalogPolicyCliResult>;
+
+type ProviderConformanceStatus = "passed" | "failed";
+interface ProviderConformanceCheck {
+    name: string;
+    status: ProviderConformanceStatus;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface ProviderConformanceSchemaValidationMode {
+    input?: boolean;
+    output?: boolean;
+}
+interface ProviderConformanceOptions<Input = unknown> {
+    manifest: ProviderManifest;
+    adapters: ProbeMeshAdapter[];
+    request: ProbeMeshCallRequest<Input>;
+    apiKey?: string;
+    expectedProviderId?: string;
+    requiredReceiptTypes?: ReceiptType[];
+    schemaValidation?: ProviderConformanceSchemaValidationMode;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderConformanceError {
+    name: "ProbeMeshError";
+    code: ProbeMeshErrorCode;
+    message: string;
+    status: "failed";
+    capability?: string;
+    provider?: string;
+    callId?: string;
+    receiptRefs?: ReceiptRef[];
+    safety?: ProbeMeshCallSafety;
+    timeline?: ProbeMeshCallResponse["timeline"];
+    retrySafety?: ProbeMeshRetrySafety;
+    route?: ProbeMeshRouteMetadata;
+}
+interface ProviderConformanceSummary {
+    status: ProviderConformanceStatus;
+    totalChecks: number;
+    passedChecks: number;
+    failedChecks: number;
+    failedCheckNames: string[];
+    callId?: string;
+    providerId?: string;
+    errorCode?: ProbeMeshErrorCode;
+    receiptTypes: ReceiptType[];
+    requiredReceiptTypes: ReceiptType[];
+    timelineEventTypes: ProbeMeshTimelineEventType[];
+    telemetryEventTypes: ProbeMeshTimelineEventType[];
+    safety?: ProbeMeshCallSafety;
+    retrySafety?: ProbeMeshRetrySafety;
+    route?: {
+        routeId?: string;
+        selectedProviderId?: string;
+        fallbackUsed?: boolean;
+        fallbackCount?: number;
+        stopReason?: ProbeMeshRouteDecisionReason;
+    };
+}
+interface ProviderConformanceResult<Data = unknown> {
+    status: ProviderConformanceStatus;
+    checks: ProviderConformanceCheck[];
+    response?: ProbeMeshCallResponse<Data>;
+    error?: ProviderConformanceError;
+    telemetryEvents: HostedTelemetryEvent[];
+    summary: ProviderConformanceSummary;
+}
+type ProviderConformanceReportFormat = "json" | "markdown";
+interface ProviderConformanceReportOptions {
+    title?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderConformanceReport {
+    title: string;
+    status: ProviderConformanceStatus;
+    summary: ProviderConformanceSummary;
+    checks: ProviderConformanceCheck[];
+    receipts: {
+        total: number;
+        types: ReceiptType[];
+        providers: string[];
+        byType: Partial<Record<ReceiptType, number>>;
+        hasPaymentProof: boolean;
+        hasSettlementConfirmation: boolean;
+        hasProviderDelivery: boolean;
+    };
+    route?: ProviderConformanceSummary["route"];
+    timelineEventTypes: ProbeMeshTimelineEventType[];
+    telemetryEventTypes: ProbeMeshTimelineEventType[];
+    safety?: ProbeMeshCallSafety;
+    retrySafety?: ProbeMeshRetrySafety;
+    error?: ProviderConformanceError;
+}
+declare function runProviderConformance<Input = unknown, Data = unknown>(options: ProviderConformanceOptions<Input>): Promise<ProviderConformanceResult<Data>>;
+declare function createProviderConformanceReport(result: ProviderConformanceResult, options?: ProviderConformanceReportOptions): ProviderConformanceReport;
+declare function formatProviderConformanceReport(report: ProviderConformanceReport, options?: {
+    format?: ProviderConformanceReportFormat;
+}): string;
+
+declare const PROVIDER_CONFORMANCE_ARTIFACT_SCHEMA_VERSION: "probemesh.provider-conformance.v1";
+type ProviderConformanceArtifactStatus = "verified" | "failed";
+type ProviderConformanceArtifactFormat = "json" | "markdown";
+interface ProviderConformanceArtifactOptions {
+    manifest: ProviderManifest;
+    report: ProviderConformanceReport;
+    generatedAt?: string;
+    artifactId?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderConformanceArtifactManifestSummary {
+    id: string;
+    displayName: string;
+    capabilities: string[];
+    protocolMode: string;
+    pricing?: Cost | Record<string, Cost>;
+    receipts: ProviderReceiptSupport;
+    limits?: ProviderLimits;
+    paymentOptions?: ProviderPaymentOption[];
+    schemas: {
+        inputDeclared: boolean;
+        outputDeclared: boolean;
+    };
+}
+interface ProviderConformanceArtifactReceiptSummary {
+    total: number;
+    types: ReceiptType[];
+    providers: string[];
+    byType: Partial<Record<ReceiptType, number>>;
+    hasPaymentProof: boolean;
+    hasSettlementConfirmation: boolean;
+    hasProviderDelivery: boolean;
+}
+interface ProviderConformanceArtifactHashes {
+    manifest: string;
+    report: string;
+    checks: string;
+    artifact: string;
+}
+interface ProviderConformanceArtifact {
+    schemaVersion: typeof PROVIDER_CONFORMANCE_ARTIFACT_SCHEMA_VERSION;
+    artifactId: string;
+    generatedAt: string;
+    status: ProviderConformanceArtifactStatus;
+    hashAlgorithm: "sha256";
+    hashes: ProviderConformanceArtifactHashes;
+    provider: ProviderConformanceArtifactManifestSummary;
+    conformance: {
+        title: string;
+        status: ProviderConformanceStatus;
+        summary: ProviderConformanceSummary;
+        checks: ProviderConformanceCheck[];
+        failedChecks: string[];
+        receipts: ProviderConformanceArtifactReceiptSummary;
+        safety?: ProbeMeshCallSafety;
+        retrySafety?: ProbeMeshRetrySafety;
+        route?: ProviderConformanceSummary["route"];
+        timelineEventTypes: ProbeMeshTimelineEventType[];
+        telemetryEventTypes: ProbeMeshTimelineEventType[];
+        errorCode?: string;
+    };
+}
+interface ProviderConformanceArtifactValidationError {
+    path: string;
+    message: string;
+}
+interface ProviderConformanceArtifactValidationResult {
+    valid: boolean;
+    errors: ProviderConformanceArtifactValidationError[];
+}
+declare function createProviderConformanceArtifact(options: ProviderConformanceArtifactOptions): ProviderConformanceArtifact;
+declare function validateProviderConformanceArtifact(artifact: unknown): ProviderConformanceArtifactValidationResult;
+declare function assertProviderConformanceArtifact(artifact: unknown): asserts artifact is ProviderConformanceArtifact;
+declare function formatProviderConformanceArtifact(artifact: ProviderConformanceArtifact, options?: {
+    format?: ProviderConformanceArtifactFormat;
+}): string;
+
+interface ProviderConformanceCliSkip {
+    skip: true;
+    reason: string;
+    details?: unknown;
+}
+interface ProviderConformanceCliOutputs {
+    json?: string;
+    markdown?: string;
+    artifact?: string;
+}
+interface ProviderConformanceCliArtifact extends Omit<ProviderConformanceArtifactOptions, "manifest" | "report"> {
+    format?: "json" | "markdown";
+}
+interface ProviderConformanceCliConfig {
+    conformance: ProviderConformanceOptions;
+    report?: ProviderConformanceReportOptions & {
+        format?: ProviderConformanceReportFormat;
+    };
+    artifact?: ProviderConformanceCliArtifact;
+    outputs?: ProviderConformanceCliOutputs;
+}
+type ProviderConformanceCliConfigExport = ProviderConformanceCliConfig | ProviderConformanceCliSkip;
+type ProviderConformanceCliConfigFactory = (context: ProviderConformanceCliConfigContext) => ProviderConformanceCliConfigExport | Promise<ProviderConformanceCliConfigExport>;
+interface ProviderConformanceCliConfigContext {
+    argv: string[];
+    cwd: string;
+}
+interface ProviderConformanceCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface ProviderConformanceCliResult {
+    exitCode: 0 | 1 | 2;
+    skipped: boolean;
+    skip?: ProviderConformanceCliSkip;
+    result?: ProviderConformanceResult;
+    report?: ProviderConformanceReport;
+    artifact?: ProviderConformanceArtifact;
+    stdout: string;
+    stderr?: string;
+    artifactPaths?: ProviderConformanceCliOutputs;
+}
+declare function runProviderConformanceCli(options?: ProviderConformanceCliOptions): Promise<ProviderConformanceCliResult>;
+
+declare const PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION: "probemesh.provider-onboarding-dossier.v1";
+type ProviderOnboardingDossierStatus = "ready" | "failed";
+type ProviderOnboardingDossierFormat = "json" | "markdown";
+interface ProviderOnboardingDossierOptions {
+    catalogArtifact: ProviderCatalogArtifact;
+    conformanceArtifact: ProviderConformanceArtifact;
+    generatedAt?: string;
+    dossierId?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderOnboardingDossierProviderSummary {
+    id: string;
+    displayName: string;
+    capabilities: string[];
+    protocolMode: string;
+    pricing?: Cost | Record<string, Cost>;
+    paymentOptions?: ProviderPaymentOption[];
+}
+interface ProviderOnboardingDossierReadiness {
+    ready: boolean;
+    status: ProviderOnboardingDossierStatus;
+    reasons: string[];
+    failedChecks: string[];
+}
+interface ProviderOnboardingDossierReceiptSummary extends ProviderConformanceArtifactReceiptSummary {
+}
+interface ProviderOnboardingDossierEvidence {
+    catalog: {
+        artifactId: string;
+        status: ProviderCatalogArtifactStatus;
+        acceptanceStatus: ProviderCatalogArtifact["acceptance"]["status"];
+        gateStatus: ProviderCatalogArtifact["acceptance"]["gate"]["status"];
+        accepted: boolean;
+        failedChecks: string[];
+    };
+    conformance: {
+        artifactId: string;
+        status: ProviderConformanceArtifactStatus;
+        conformanceStatus: ProviderConformanceArtifact["conformance"]["status"];
+        failedChecks: string[];
+    };
+    receipts: ProviderOnboardingDossierReceiptSummary;
+    safety: {
+        acceptance?: ProbeMeshCallSafety;
+        conformance?: ProbeMeshCallSafety;
+    };
+    retrySafety: {
+        acceptance?: ProbeMeshRetrySafety;
+        conformance?: ProbeMeshRetrySafety;
+    };
+    route: {
+        acceptance?: ProviderCatalogArtifact["acceptance"]["route"];
+        conformance?: ProviderConformanceArtifact["conformance"]["route"];
+    };
+    timelineEventTypes: ProbeMeshTimelineEventType[];
+    telemetryEventTypes: ProbeMeshTimelineEventType[];
+}
+interface ProviderOnboardingDossierHashes {
+    catalogArtifact: string;
+    conformanceArtifact: string;
+    readiness: string;
+    dossier: string;
+}
+interface ProviderOnboardingDossier {
+    schemaVersion: typeof PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION;
+    dossierId: string;
+    generatedAt: string;
+    status: ProviderOnboardingDossierStatus;
+    hashAlgorithm: "sha256";
+    hashes: ProviderOnboardingDossierHashes;
+    provider: ProviderOnboardingDossierProviderSummary;
+    readiness: ProviderOnboardingDossierReadiness;
+    evidence: ProviderOnboardingDossierEvidence;
+    artifacts: {
+        catalog: ProviderCatalogArtifact;
+        conformance: ProviderConformanceArtifact;
+    };
+}
+interface ProviderOnboardingDossierValidationError {
+    path: string;
+    message: string;
+}
+interface ProviderOnboardingDossierValidationResult {
+    valid: boolean;
+    errors: ProviderOnboardingDossierValidationError[];
+}
+declare function createProviderOnboardingDossier(options: ProviderOnboardingDossierOptions): ProviderOnboardingDossier;
+declare function validateProviderOnboardingDossier(dossier: unknown): ProviderOnboardingDossierValidationResult;
+declare function assertProviderOnboardingDossier(dossier: unknown): asserts dossier is ProviderOnboardingDossier;
+declare function formatProviderOnboardingDossier(dossier: ProviderOnboardingDossier, options?: {
+    format?: ProviderOnboardingDossierFormat;
+    title?: string;
+}): string;
+
+type ProviderOnboardingDossierImportStatus = "passed" | "failed";
+type ProviderOnboardingDossierImportCheckStatus = "passed" | "failed";
+type ProviderOnboardingDossierImportReportFormat = "json" | "markdown";
+interface ProviderCatalogFromOnboardingDossiersOptions {
+    dossiers: ProviderOnboardingDossier[];
+    generatedAt?: string;
+}
+interface ProviderOnboardingDossierPolicyEvaluationOptions {
+    catalogPolicy?: ProviderCatalogPolicyOptions;
+    adapterInventory: ProviderCatalogPolicyAdapterInventory;
+    queries: ProviderCatalogPolicyExpectedQuery[];
+}
+interface ProviderOnboardingDossierEvaluationOptions extends ProviderCatalogFromOnboardingDossiersOptions {
+    policy?: ProviderOnboardingDossierPolicyEvaluationOptions;
+}
+interface HostedCatalogPolicyFromOnboardingDossiersOptions extends ProviderCatalogFromOnboardingDossiersOptions, ProviderCatalogPolicyOptions {
+    adapterInventory: ProviderCatalogPolicyAdapterInventory;
+    queries: ProviderCatalogPolicyExpectedQuery[];
+}
+interface HostedCatalogPolicyFromOnboardingDossiersResult {
+    catalogPolicy: HostedProviderCatalogPolicyOptions;
+    evaluation: ProviderOnboardingDossierEvaluationResult;
+}
+interface ProviderOnboardingDossierImportCheck {
+    name: string;
+    status: ProviderOnboardingDossierImportCheckStatus;
+    message: string;
+    dossierId?: string;
+    providerId?: string;
+}
+interface ProviderOnboardingDossierImportDossierResult {
+    dossierId: string;
+    providerId: string;
+    status: ProviderOnboardingDossierStatus;
+    catalogArtifactId: string;
+    conformanceArtifactId: string;
+    imported: boolean;
+    reasons: string[];
+    failedChecks: string[];
+}
+interface ProviderOnboardingDossierEvaluationResult {
+    status: ProviderOnboardingDossierImportStatus;
+    checks: ProviderOnboardingDossierImportCheck[];
+    summary: ProviderCatalogSummary & {
+        totalDossiers: number;
+        readyDossiers: number;
+        failedDossiers: number;
+        importedDossiers: number;
+        excludedDossiers: number;
+        policyStatus?: ProviderCatalogPolicyEvaluationResult["status"];
+    };
+    catalog: ProviderCatalog;
+    dossiers: ProviderOnboardingDossierImportDossierResult[];
+    policyEvaluation?: ProviderCatalogPolicyEvaluationResult;
+}
+interface ProviderOnboardingDossierImportReportOptions {
+    title?: string;
+    generatedAt?: string;
+    forbiddenOutputValues?: string[];
+}
+interface ProviderOnboardingDossierImportReport {
+    title: string;
+    generatedAt: string;
+    status: ProviderOnboardingDossierImportStatus;
+    summary: ProviderOnboardingDossierEvaluationResult["summary"];
+    checks: ProviderOnboardingDossierImportCheck[];
+    dossiers: ProviderOnboardingDossierImportDossierResult[];
+    policyEvaluation?: ProviderCatalogPolicyEvaluationResult;
+}
+declare function parseProviderOnboardingDossierJson(json: string): ProviderOnboardingDossier;
+declare function createProviderCatalogFromOnboardingDossiers(options: ProviderCatalogFromOnboardingDossiersOptions): ProviderCatalog;
+declare function evaluateProviderOnboardingDossiers(options: ProviderOnboardingDossierEvaluationOptions): ProviderOnboardingDossierEvaluationResult;
+declare function createHostedCatalogPolicyFromOnboardingDossiers(options: HostedCatalogPolicyFromOnboardingDossiersOptions): HostedCatalogPolicyFromOnboardingDossiersResult;
+declare function createProviderOnboardingDossierImportReport(result: ProviderOnboardingDossierEvaluationResult, options?: ProviderOnboardingDossierImportReportOptions): ProviderOnboardingDossierImportReport;
+declare function formatProviderOnboardingDossierImportReport(report: ProviderOnboardingDossierImportReport, options?: {
+    format?: ProviderOnboardingDossierImportReportFormat;
+}): string;
+
+interface ProviderDossierCheckCliSkip {
+    skip: true;
+    reason: string;
+    details?: unknown;
+}
+interface ProviderDossierCheckCliCatalog {
+    generatedAt?: string;
+}
+interface ProviderDossierCheckCliOutputs {
+    json?: string;
+    markdown?: string;
+    catalog?: string;
+}
+interface ProviderDossierCheckCliConfig {
+    dossiers?: ProviderOnboardingDossier[];
+    dossierFiles?: string[];
+    catalog?: ProviderDossierCheckCliCatalog;
+    policy?: ProviderOnboardingDossierPolicyEvaluationOptions;
+    report?: ProviderOnboardingDossierImportReportOptions & {
+        format?: ProviderOnboardingDossierImportReportFormat;
+    };
+    outputs?: ProviderDossierCheckCliOutputs;
+}
+type ProviderDossierCheckCliConfigExport = ProviderDossierCheckCliConfig | ProviderDossierCheckCliSkip;
+type ProviderDossierCheckCliConfigFactory = (context: ProviderDossierCheckCliConfigContext) => ProviderDossierCheckCliConfigExport | Promise<ProviderDossierCheckCliConfigExport>;
+interface ProviderDossierCheckCliConfigContext {
+    argv: string[];
+    cwd: string;
+}
+interface ProviderDossierCheckCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface ProviderDossierCheckCliResult {
+    exitCode: 0 | 1 | 2;
+    skipped: boolean;
+    skip?: ProviderDossierCheckCliSkip;
+    evaluation?: ProviderOnboardingDossierEvaluationResult;
+    report?: ProviderOnboardingDossierImportReport;
+    catalog?: ProviderCatalog;
+    stdout: string;
+    stderr?: string;
+    artifactPaths?: ProviderDossierCheckCliOutputs;
+}
+declare function runProviderDossierCheckCli(options?: ProviderDossierCheckCliOptions): Promise<ProviderDossierCheckCliResult>;
+
+interface ProviderOnboardingDossierCliSkip {
+    skip: true;
+    reason: string;
+    details?: unknown;
+}
+interface ProviderOnboardingDossierCliOutputs {
+    json?: string;
+    markdown?: string;
+}
+interface ProviderOnboardingDossierCliDossier extends Omit<ProviderOnboardingDossierOptions, "catalogArtifact" | "conformanceArtifact"> {
+    format?: ProviderOnboardingDossierFormat;
+    title?: string;
+}
+interface ProviderOnboardingDossierCliConfig {
+    catalogArtifact?: ProviderCatalogArtifact;
+    catalogArtifactFile?: string;
+    conformanceArtifact?: ProviderConformanceArtifact;
+    conformanceArtifactFile?: string;
+    dossier?: ProviderOnboardingDossierCliDossier;
+    outputs?: ProviderOnboardingDossierCliOutputs;
+}
+type ProviderOnboardingDossierCliConfigExport = ProviderOnboardingDossierCliConfig | ProviderOnboardingDossierCliSkip;
+type ProviderOnboardingDossierCliConfigFactory = (context: ProviderOnboardingDossierCliConfigContext) => ProviderOnboardingDossierCliConfigExport | Promise<ProviderOnboardingDossierCliConfigExport>;
+interface ProviderOnboardingDossierCliConfigContext {
+    argv: string[];
+    cwd: string;
+}
+interface ProviderOnboardingDossierCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface ProviderOnboardingDossierCliResult {
+    exitCode: 0 | 1 | 2;
+    skipped: boolean;
+    skip?: ProviderOnboardingDossierCliSkip;
+    dossier?: ProviderOnboardingDossier;
+    stdout: string;
+    stderr?: string;
+    artifactPaths?: ProviderOnboardingDossierCliOutputs;
+}
+declare function runProviderOnboardingDossierCli(options?: ProviderOnboardingDossierCliOptions): Promise<ProviderOnboardingDossierCliResult>;
+
+type ProbeMeshIntegrationTemplateId = "provider-x402-sandbox" | "buyer-hosted-router" | "catalog-policy-ci" | "audit-trail-export";
+interface ProbeMeshIntegrationTemplateFile {
+    path: string;
+    content: string;
+    executable?: boolean;
+}
+interface ProbeMeshIntegrationTemplate {
+    id: ProbeMeshIntegrationTemplateId;
+    name: string;
+    description: string;
+    files: ProbeMeshIntegrationTemplateFile[];
+}
+interface ProbeMeshIntegrationTemplateRenderOptions {
+    templateId: ProbeMeshIntegrationTemplateId | string;
+    packageName?: string;
+    sdkVersion?: string;
+}
+interface ProbeMeshIntegrationTemplateRenderResult {
+    template: ProbeMeshIntegrationTemplate;
+    packageName: string;
+    files: ProbeMeshIntegrationTemplateFile[];
+}
+declare function listProbeMeshIntegrationTemplates(): {
+    files: {
+        path: string;
+        content: string;
+        executable?: boolean;
+    }[];
+    id: ProbeMeshIntegrationTemplateId;
+    name: string;
+    description: string;
+}[];
+declare function getProbeMeshIntegrationTemplate(id: ProbeMeshIntegrationTemplateId | string): {
+    files: {
+        path: string;
+        content: string;
+        executable?: boolean;
+    }[];
+    id: ProbeMeshIntegrationTemplateId;
+    name: string;
+    description: string;
+};
+declare function renderProbeMeshIntegrationTemplate(options: ProbeMeshIntegrationTemplateRenderOptions): ProbeMeshIntegrationTemplateRenderResult;
+
+interface ProbeMeshInitCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface ProbeMeshInitCliResult {
+    exitCode: 0 | 2;
+    listed: boolean;
+    dryRun: boolean;
+    stdout: string;
+    stderr?: string;
+    templateId?: ProbeMeshIntegrationTemplateId | string;
+    outDir?: string;
+    files?: ProbeMeshIntegrationTemplateFile[];
+}
+declare function runProbeMeshInitCli(options?: ProbeMeshInitCliOptions): Promise<ProbeMeshInitCliResult>;
+
+type ProviderManifestCapabilityHandler<Input = unknown, Data = unknown> = (request: ProbeMeshAdapterCallRequest<Input>, context: ProviderManifestHandlerContext) => ProbeMeshAdapterCallResult<Data> | Promise<ProbeMeshAdapterCallResult<Data>>;
+type ProviderManifestHandlers = Record<string, ProviderManifestCapabilityHandler>;
+declare function createAdapterFromManifest(manifest: ProviderManifest, handlers: ProviderManifestHandlers, options?: CreateAdapterFromManifestOptions): ProbeMeshAdapter;
+
+type ApiKeyPlacement = "header" | "authorization";
+type ApiKeyResolver = (() => string | undefined) | (() => Promise<string | undefined>);
+interface ApiKeyProtocolOptions {
+    mode?: ProviderProtocolMode;
+    providerId?: string;
+    apiKey?: string;
+    resolveApiKey?: ApiKeyResolver;
+    placement?: ApiKeyPlacement;
+    headerName?: string;
+    authorizationScheme?: string;
+}
+declare function createApiKeyProtocol(options?: ApiKeyProtocolOptions): ProviderProtocolAdapter;
+
+type X402PaymentRequired = PaymentRequired;
+type X402PaymentRequirements = PaymentRequirements;
+type X402PaymentPayload = PaymentPayload;
+type X402ResourceInfo = ResourceInfo;
+type X402SettlementResponse = SettleResponse;
+type X402VerifyResponse = VerifyResponse;
+interface X402PaymentRequiredConfig {
+    x402Version?: number;
+    error?: string;
+    resource?: string | Partial<X402ResourceInfo>;
+    accepts?: X402PaymentRequirements[];
+    extensions?: Record<string, unknown>;
+    scheme?: string;
+    network?: string;
+    asset?: string;
+    amount?: string;
+    payTo?: string;
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+}
+interface X402PaymentRequiredResolverInput {
+    manifest: ProviderManifest;
+    request: ProbeMeshAdapterCallRequest;
+    context: ProbeMeshAdapterContext;
+}
+type X402PaymentRequiredResolver = (input: X402PaymentRequiredResolverInput) => X402PaymentRequired | Promise<X402PaymentRequired>;
+interface X402SignerInput {
+    paymentRequired: X402PaymentRequired;
+    paymentRequirements: X402PaymentRequirements;
+    manifest: ProviderManifest;
+    request: ProbeMeshAdapterCallRequest;
+    context: ProbeMeshAdapterContext;
+    providerId: string;
+    capability: string;
+    callId: string;
+    paymentId: string;
+    payer: string;
+}
+interface X402SignerResult {
+    paymentPayload: X402PaymentPayload;
+    payer?: string;
+    metadata?: Record<string, unknown>;
+}
+type X402Signer = (input: X402SignerInput) => X402SignerResult | Promise<X402SignerResult>;
+interface X402FacilitatorVerifyInput {
+    paymentPayload: X402PaymentPayload;
+    paymentRequirements: X402PaymentRequirements;
+    paymentRequired: X402PaymentRequired;
+    manifest: ProviderManifest;
+    request: ProbeMeshAdapterCallRequest;
+    context: ProbeMeshAdapterContext;
+    providerId: string;
+    capability: string;
+    callId: string;
+}
+type X402FacilitatorVerifyResult = X402VerifyResponse;
+interface X402FacilitatorSettleInput {
+    paymentPayload: X402PaymentPayload;
+    paymentRequirements: X402PaymentRequirements;
+    paymentRequired: X402PaymentRequired;
+    result: ProbeMeshAdapterCallResult;
+    manifest: ProviderManifest;
+    request: ProbeMeshAdapterCallRequest;
+    context: ProbeMeshAdapterContext;
+    providerId: string;
+    capability: string;
+    callId: string;
+}
+type X402FacilitatorSettleResult = X402SettlementResponse;
+interface X402Facilitator {
+    verify(input: X402FacilitatorVerifyInput): X402FacilitatorVerifyResult | Promise<X402FacilitatorVerifyResult>;
+    settle(input: X402FacilitatorSettleInput): X402FacilitatorSettleResult | Promise<X402FacilitatorSettleResult>;
+}
+interface X402ProtocolOptions {
+    mode?: ProviderProtocolMode;
+    providerId?: string;
+    payer?: string;
+    paymentId?: string;
+    paymentRequired?: X402PaymentRequiredConfig;
+    resolvePaymentRequired?: X402PaymentRequiredResolver;
+    signer?: X402Signer;
+    facilitator?: X402Facilitator;
+}
+interface X402LocalSignerOptions {
+    payer?: string;
+    paymentId?: string;
+    failSign?: boolean;
+    payload?: Record<string, unknown>;
+}
+interface X402LocalFacilitatorOptions {
+    payer?: string;
+    failVerify?: boolean;
+    failSettle?: boolean;
+    invalidReason?: string;
+    invalidMessage?: string;
+    errorReason?: string;
+    errorMessage?: string;
+    transaction?: string;
+}
+declare function createX402Protocol(options?: X402ProtocolOptions): ProviderProtocolAdapter;
+declare function createX402LocalSigner(options?: X402LocalSignerOptions): X402Signer;
+declare function createX402LocalFacilitator(options?: X402LocalFacilitatorOptions): X402Facilitator;
+
+type X402EvmPrivateKey = `0x${string}`;
+type X402EvmAddress = `0x${string}`;
+type X402EvmClientSigner = ClientEvmSigner;
+interface X402EvmNetworkConfig {
+    network?: Network;
+    networks?: Network[];
+    rpcUrl?: string;
+    schemeOptions?: ExactEvmSchemeOptions;
+}
+interface X402EvmSignerMetadata {
+    signer: "evm";
+    scheme: "exact";
+    address: X402EvmAddress;
+    networks: Network[];
+    rpcConfigured: boolean;
+}
+interface X402EvmSignerOptions extends X402EvmNetworkConfig {
+    privateKey?: X402EvmPrivateKey;
+    signer?: X402EvmClientSigner | PrivateKeyAccount;
+}
+interface X402HttpFacilitatorAuthHeaders {
+    verify: Record<string, string>;
+    settle: Record<string, string>;
+    supported: Record<string, string>;
+    bazaar?: Record<string, string>;
+}
+type X402HttpFacilitatorAuthHeaderResolver = () => X402HttpFacilitatorAuthHeaders | Promise<X402HttpFacilitatorAuthHeaders>;
+interface X402HttpFacilitatorOptions {
+    url?: string;
+    createAuthHeaders?: X402HttpFacilitatorAuthHeaderResolver;
+    timeoutMs?: number;
+}
+type X402EvmTestnetEnv = Record<string, string | undefined>;
+interface X402EvmTestnetConfigOptions {
+    env?: X402EvmTestnetEnv;
+    defaultNetwork?: Network;
+    defaultAmount?: string;
+    defaultFacilitatorUrl?: string;
+}
+interface X402EvmTestnetConfig {
+    privateKey: X402EvmPrivateKey;
+    network: Network;
+    rpcUrl?: string;
+    facilitatorUrl: string;
+    amount: string;
+    asset: X402EvmAddress;
+    payTo: X402EvmAddress;
+    assetMetadata: {
+        name: string;
+        version: string;
+    };
+}
+interface X402EvmTestnetConfigSummary {
+    network: Network;
+    rpcConfigured: boolean;
+    facilitatorUrl: string;
+    amount: string;
+    asset: X402EvmAddress;
+    payTo: X402EvmAddress;
+    assetMetadata: {
+        name: string;
+        version: string;
+    };
+    privateKeyConfigured: boolean;
+}
+interface X402EvmTestnetConfigSkip {
+    reason: string;
+    missingEnv: string[];
+    requiredEnv: string[];
+    optionalEnv: string[];
+    defaults: {
+        network: Network;
+        amount: string;
+        facilitatorUrl: string;
+    };
+}
+type X402EvmTestnetConfigResult = {
+    ok: true;
+    config: X402EvmTestnetConfig;
+    summary: X402EvmTestnetConfigSummary;
+} | {
+    ok: false;
+    skip: X402EvmTestnetConfigSkip;
+};
+declare function resolveX402EvmTestnetConfig(options?: X402EvmTestnetConfigOptions): X402EvmTestnetConfigResult;
+declare function createX402EvmSigner(options?: X402EvmSignerOptions): X402Signer;
+declare function createX402HttpFacilitator(options?: X402HttpFacilitatorOptions): X402Facilitator;
+
+interface X402ProviderAcceptanceCliSkip {
+    skip: true;
+    reason: string;
+    details?: unknown;
+}
+interface X402ProviderAcceptanceCliOutputs {
+    json?: string;
+    markdown?: string;
+    catalog?: string;
+}
+interface X402ProviderAcceptanceCliCatalog {
+    manifest: ProviderManifest;
+    artifactId?: string;
+    generatedAt?: string;
+}
+interface X402ProviderAcceptanceCliConfig<Input = unknown> {
+    acceptance: X402ProviderAcceptanceOptions<Input>;
+    report?: X402ProviderAcceptanceReportOptions & {
+        format?: X402ProviderAcceptanceReportFormat;
+    };
+    catalog?: X402ProviderAcceptanceCliCatalog;
+    outputs?: X402ProviderAcceptanceCliOutputs;
+}
+type X402ProviderAcceptanceCliConfigExport<Input = unknown> = X402ProviderAcceptanceCliConfig<Input> | X402ProviderAcceptanceCliSkip;
+type X402ProviderAcceptanceCliConfigFactory<Input = unknown> = (context: X402ProviderAcceptanceCliConfigContext) => X402ProviderAcceptanceCliConfigExport<Input> | Promise<X402ProviderAcceptanceCliConfigExport<Input>>;
+interface X402ProviderAcceptanceCliConfigContext {
+    argv: string[];
+    cwd: string;
+}
+interface X402ProviderAcceptanceCliOptions {
+    argv?: string[];
+    cwd?: string;
+}
+interface X402ProviderAcceptanceCliResult {
+    exitCode: 0 | 1 | 2;
+    skipped: boolean;
+    skip?: X402ProviderAcceptanceCliSkip;
+    report?: X402ProviderAcceptanceReport;
+    catalogArtifact?: ProviderCatalogArtifact;
+    stdout: string;
+    stderr?: string;
+    artifactPaths?: X402ProviderAcceptanceCliOutputs;
+}
+declare function runX402ProviderAcceptanceCli(options?: X402ProviderAcceptanceCliOptions): Promise<X402ProviderAcceptanceCliResult>;
+
+interface X402SecretRedactionOptions {
+    replacement?: string;
+    maxDepth?: number;
+}
+declare function redactX402Secrets<T>(value: T, options?: X402SecretRedactionOptions): T;
+
+interface X402SandboxPaymentRequirement {
+    x402Version: 2;
+    scheme: "exact" | "upto" | string;
+    network: string;
+    asset: string;
+    amount: string;
+    payTo: string;
+    resource: string;
+    description?: string;
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+}
+interface X402SandboxPaymentPayload {
+    x402Version: 2;
+    scheme: string;
+    network: string;
+    asset: string;
+    amount: string;
+    payTo: string;
+    resource: string;
+    payer: string;
+    provider: string;
+    callId: string;
+    paymentId: string;
+    issuedAt: string;
+    sandboxSignature: string;
+}
+interface X402SandboxSettlementResponse {
+    x402Version: 2;
+    success: boolean;
+    provider: string;
+    payer: string;
+    paymentId: string;
+    paymentAttemptId: string;
+    network: string;
+    asset: string;
+    amount: string;
+    settledAt: string;
+    sandboxSettlementId: string;
+}
+interface X402SandboxProtocolOptions {
+    mode?: ProviderProtocolMode;
+    providerId?: string;
+    failPrepare?: boolean;
+    failSettle?: boolean;
+    paymentId?: string;
+    payer?: string;
+    paymentRequired?: Partial<X402SandboxPaymentRequirement>;
+}
+declare function createX402SandboxProtocol(options?: X402SandboxProtocolOptions): ProviderProtocolAdapter;
+
+type ReceiptSource = ProbeMeshCallResponse | ReceiptRef[];
+interface ReceiptSummary {
+    total: number;
+    types: ReceiptType[];
+    providers: string[];
+    byType: Partial<Record<ReceiptType, number>>;
+    hasPaymentProof: boolean;
+    hasProviderDelivery: boolean;
+}
+declare function getReceiptRefs(source: ReceiptSource, type?: ReceiptType): ReceiptRef[];
+declare function findReceiptRef(source: ReceiptSource, type: ReceiptType): ReceiptRef | undefined;
+declare function hasReceipt(source: ReceiptSource, type: ReceiptType): boolean;
+declare function summarizeReceipts(source: ReceiptSource): ReceiptSummary;
+
+interface PaymentOptionResolutionInput {
+    providerId: string;
+    providerMode?: string;
+    capabilities: string[];
+    capability: string;
+    pricing?: ProbeMeshPricing | Record<string, ProbeMeshPricing>;
+    paymentOptions?: ProviderPaymentOption[];
+    paymentPreferences?: ProbeMeshPaymentPreferences;
+    paymentStrategy?: ProbeMeshPaymentStrategy;
+    defaultReceiptTypes?: ReceiptType[];
+}
+interface PaymentOptionResolution {
+    selection?: ProbeMeshPaymentSelection;
+    reason?: string;
+    options: ProviderPaymentOption[];
+}
+declare function resolveProviderPaymentOption(input: PaymentOptionResolutionInput): PaymentOptionResolution;
+declare function getProviderPaymentOptions(input: Omit<PaymentOptionResolutionInput, "capability" | "paymentPreferences">): ProviderPaymentOption[];
+declare function validatePaymentStrategy(paymentStrategy: unknown, capability: string): void;
+declare function mergePaymentPreferences(first?: ProbeMeshPaymentPreferences, second?: ProbeMeshPaymentPreferences): ProbeMeshPaymentPreferences | undefined;
+
+interface JsonSchemaLikeValidationError {
+    path: string;
+    message: string;
+}
+interface JsonSchemaLikeValidationResult {
+    valid: boolean;
+    errors: JsonSchemaLikeValidationError[];
+}
+interface JsonSchemaLikeValidationOptions {
+    path?: string;
+}
+declare function validateJsonSchemaLikeValue(value: unknown, schema: JsonSchemaLike, options?: JsonSchemaLikeValidationOptions): JsonSchemaLikeValidationResult;
+declare function assertJsonSchemaLikeValue(value: unknown, schema: JsonSchemaLike, options?: JsonSchemaLikeValidationOptions): void;
+
+export { type ApiKeyPlacement, type ApiKeyProtocolOptions, type ApiKeyResolver, type CallStatus, type Cost, type CreateAdapterFromManifestOptions, type DeliveryStatus, type HostedAuditArtifactOptions, type HostedCatalogPolicyFromOnboardingDossiersOptions, type HostedCatalogPolicyFromOnboardingDossiersResult, type HostedProviderHealthOptions, type HostedRouter, type HostedRouterOptions, type HostedTelemetryEvent, type HostedTelemetryEventType, type JsonSchemaLike, type JsonSchemaLikeValidationError, type JsonSchemaLikeValidationOptions, type JsonSchemaLikeValidationResult, type MockPaymentProtocolOptions, PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION, PROBEMESH_CALL_AUDIT_ARTIFACT_SCHEMA_VERSION, PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION, PROVIDER_CATALOG_POLICY_BUNDLE_SCHEMA_VERSION, PROVIDER_CATALOG_SCHEMA_VERSION, PROVIDER_CONFORMANCE_ARTIFACT_SCHEMA_VERSION, PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION, type PaidPriceLookupData, type PaidPriceLookupFailureMode, type PaidPriceLookupProviderOptions, type PaymentStatus, type PriceLookupAdapterOptions, type PriceLookupData, type PriceLookupInput, type ProbeMeshAdapter, type ProbeMeshAdapterCallResult, type ProbeMeshAdapterContext, type ProbeMeshAttemptMetadata, type ProbeMeshAuditTrailBundle, type ProbeMeshAuditTrailBundleFormat, type ProbeMeshAuditTrailBundleHashes, type ProbeMeshAuditTrailBundleOptions, type ProbeMeshAuditTrailBundleStatus, type ProbeMeshAuditTrailBundleSummary, type ProbeMeshAuditTrailBundleValidationError, type ProbeMeshAuditTrailBundleValidationResult, type ProbeMeshAuditTrailCollector, type ProbeMeshAuditTrailExportCliBundle, type ProbeMeshAuditTrailExportCliConfig, type ProbeMeshAuditTrailExportCliConfigContext, type ProbeMeshAuditTrailExportCliConfigExport, type ProbeMeshAuditTrailExportCliConfigFactory, type ProbeMeshAuditTrailExportCliOptions, type ProbeMeshAuditTrailExportCliOutputs, type ProbeMeshAuditTrailExportCliResult, type ProbeMeshAuditTrailExportCliSkip, type ProbeMeshCallAuditArtifact, type ProbeMeshCallAuditArtifactCallSummary, type ProbeMeshCallAuditArtifactEvidence, type ProbeMeshCallAuditArtifactFormat, type ProbeMeshCallAuditArtifactHashes, type ProbeMeshCallAuditArtifactOptions, type ProbeMeshCallAuditArtifactReceiptSummary, type ProbeMeshCallAuditArtifactRequestProof, type ProbeMeshCallAuditArtifactStatus, type ProbeMeshCallAuditArtifactTimelineEvent, type ProbeMeshCallAuditArtifactTimelineSummary, type ProbeMeshCallAuditArtifactValidationError, type ProbeMeshCallAuditArtifactValidationResult, type ProbeMeshCallRequest, type ProbeMeshCallResponse, type ProbeMeshCallSafety, type ProbeMeshCallTimeline, type ProbeMeshClient, type ProbeMeshClientOptions, type ProbeMeshConstraints, ProbeMeshError, type ProbeMeshErrorCode, type ProbeMeshHostedClientOptions, type ProbeMeshInitCliOptions, type ProbeMeshInitCliResult, type ProbeMeshIntegrationTemplate, type ProbeMeshIntegrationTemplateFile, type ProbeMeshIntegrationTemplateId, type ProbeMeshIntegrationTemplateRenderOptions, type ProbeMeshIntegrationTemplateRenderResult, type ProbeMeshLocalClientOptions, type ProbeMeshPaymentPreferences, type ProbeMeshPaymentSelection, type ProbeMeshPaymentStrategy, type ProbeMeshPaymentStrategyMode, type ProbeMeshPricing, type ProbeMeshProviderHealthStatus, type ProbeMeshProviderRouteAttempt, type ProbeMeshProviderRouteAttemptStatus, type ProbeMeshRetryRequest, type ProbeMeshRetrySafety, type ProbeMeshRetrySafetyReason, type ProbeMeshRouteDecisionReason, type ProbeMeshRouteExplanation, type ProbeMeshRouteMetadata, type ProbeMeshTimelineEvent, type ProbeMeshTimelineEventType, type ProviderCatalog, type ProviderCatalogArtifact, type ProviderCatalogArtifactFormat, type ProviderCatalogArtifactOptions, type ProviderCatalogArtifactStatus, type ProviderCatalogArtifactValidationError, type ProviderCatalogArtifactValidationResult, type ProviderCatalogEntry, type ProviderCatalogFromOnboardingDossiersOptions, type ProviderCatalogMatch, type ProviderCatalogOptions, type ProviderCatalogPolicyAdapterInventory, type ProviderCatalogPolicyAdapterInventoryEntry, type ProviderCatalogPolicyBundle, type ProviderCatalogPolicyBundleAttestation, type ProviderCatalogPolicyBundleFormat, type ProviderCatalogPolicyBundleHashes, type ProviderCatalogPolicyBundleOptions, type ProviderCatalogPolicyBundleQueryCoverage, type ProviderCatalogPolicyBundleRuntimeVerificationOptions, type ProviderCatalogPolicyBundleRuntimeVerificationResult, type ProviderCatalogPolicyBundleStatus, type ProviderCatalogPolicyBundleValidationError, type ProviderCatalogPolicyBundleValidationResult, type ProviderCatalogPolicyCheck, type ProviderCatalogPolicyCheckStatus, type ProviderCatalogPolicyCliBundle, type ProviderCatalogPolicyCliConfig, type ProviderCatalogPolicyCliConfigContext, type ProviderCatalogPolicyCliConfigExport, type ProviderCatalogPolicyCliConfigFactory, type ProviderCatalogPolicyCliOptions, type ProviderCatalogPolicyCliOutputs, type ProviderCatalogPolicyCliResult, type ProviderCatalogPolicyCliSkip, type ProviderCatalogPolicyEvaluationOptions, type ProviderCatalogPolicyEvaluationResult, type ProviderCatalogPolicyEvaluationStatus, type ProviderCatalogPolicyExpectedQuery, type ProviderCatalogPolicyMissingAdapterMatch, type ProviderCatalogPolicyOptions, type ProviderCatalogPolicyQueryResult, type ProviderCatalogPolicyReport, type ProviderCatalogPolicyReportFormat, type ProviderCatalogPolicyReportOptions, type ProviderCatalogPolicySkippedProvider, type ProviderCatalogQuery, type ProviderCatalogSummary, type ProviderCatalogValidationError, type ProviderCatalogValidationResult, type ProviderConformanceArtifact, type ProviderConformanceArtifactFormat, type ProviderConformanceArtifactHashes, type ProviderConformanceArtifactManifestSummary, type ProviderConformanceArtifactOptions, type ProviderConformanceArtifactReceiptSummary, type ProviderConformanceArtifactStatus, type ProviderConformanceArtifactValidationError, type ProviderConformanceArtifactValidationResult, type ProviderConformanceCheck, type ProviderConformanceCliArtifact, type ProviderConformanceCliConfig, type ProviderConformanceCliConfigContext, type ProviderConformanceCliConfigExport, type ProviderConformanceCliConfigFactory, type ProviderConformanceCliOptions, type ProviderConformanceCliOutputs, type ProviderConformanceCliResult, type ProviderConformanceCliSkip, type ProviderConformanceError, type ProviderConformanceOptions, type ProviderConformanceReport, type ProviderConformanceReportFormat, type ProviderConformanceReportOptions, type ProviderConformanceResult, type ProviderConformanceSchemaValidationMode, type ProviderConformanceStatus, type ProviderConformanceSummary, type ProviderDossierCheckCliCatalog, type ProviderDossierCheckCliConfig, type ProviderDossierCheckCliConfigContext, type ProviderDossierCheckCliConfigExport, type ProviderDossierCheckCliConfigFactory, type ProviderDossierCheckCliOptions, type ProviderDossierCheckCliOutputs, type ProviderDossierCheckCliResult, type ProviderDossierCheckCliSkip, type ProviderLimits, type ProviderManifest, type ProviderManifestCapabilityHandler, type ProviderManifestHandlerContext, type ProviderManifestHandlers, type ProviderManifestValidationError, type ProviderManifestValidationResult, type ProviderMetadata, type ProviderMode, type ProviderOnboardingDossier, type ProviderOnboardingDossierCliConfig, type ProviderOnboardingDossierCliConfigContext, type ProviderOnboardingDossierCliConfigExport, type ProviderOnboardingDossierCliConfigFactory, type ProviderOnboardingDossierCliDossier, type ProviderOnboardingDossierCliOptions, type ProviderOnboardingDossierCliOutputs, type ProviderOnboardingDossierCliResult, type ProviderOnboardingDossierCliSkip, type ProviderOnboardingDossierEvaluationOptions, type ProviderOnboardingDossierEvaluationResult, type ProviderOnboardingDossierEvidence, type ProviderOnboardingDossierFormat, type ProviderOnboardingDossierHashes, type ProviderOnboardingDossierImportCheck, type ProviderOnboardingDossierImportCheckStatus, type ProviderOnboardingDossierImportDossierResult, type ProviderOnboardingDossierImportReport, type ProviderOnboardingDossierImportReportFormat, type ProviderOnboardingDossierImportReportOptions, type ProviderOnboardingDossierImportStatus, type ProviderOnboardingDossierOptions, type ProviderOnboardingDossierPolicyEvaluationOptions, type ProviderOnboardingDossierProviderSummary, type ProviderOnboardingDossierReadiness, type ProviderOnboardingDossierReceiptSummary, type ProviderOnboardingDossierStatus, type ProviderOnboardingDossierValidationError, type ProviderOnboardingDossierValidationResult, type ProviderPaymentOption, type ProviderPreferences, type ProviderProtocolAdapter, type ProviderProtocolExecution, type ProviderProtocolMode, type ProviderProtocolPreparation, type ProviderProtocolPrepareInput, type ProviderProtocolSettleInput, type ProviderProtocolSettlement, type ProviderReceiptSupport, type ReceiptRef, type ReceiptSource, type ReceiptStatus, type ReceiptSummary, type ReceiptType, type SettlementStatus, type StartHostedRouterOptions, type StartedHostedRouter, type X402EvmAddress, type X402EvmClientSigner, type X402EvmNetworkConfig, type X402EvmPrivateKey, type X402EvmSignerMetadata, type X402EvmSignerOptions, type X402EvmTestnetConfig, type X402EvmTestnetConfigOptions, type X402EvmTestnetConfigResult, type X402EvmTestnetConfigSkip, type X402EvmTestnetConfigSummary, type X402EvmTestnetEnv, type X402Facilitator, type X402FacilitatorSettleInput, type X402FacilitatorSettleResult, type X402FacilitatorVerifyInput, type X402FacilitatorVerifyResult, type X402HttpFacilitatorAuthHeaderResolver, type X402HttpFacilitatorAuthHeaders, type X402HttpFacilitatorOptions, type X402LocalFacilitatorOptions, type X402LocalSignerOptions, type X402PaymentPayload, type X402PaymentRequired, type X402PaymentRequiredConfig, type X402PaymentRequiredResolver, type X402PaymentRequiredResolverInput, type X402PaymentRequirements, type X402ProtocolOptions, type X402ProviderAcceptanceCheck, type X402ProviderAcceptanceCliCatalog, type X402ProviderAcceptanceCliConfig, type X402ProviderAcceptanceCliConfigContext, type X402ProviderAcceptanceCliConfigExport, type X402ProviderAcceptanceCliConfigFactory, type X402ProviderAcceptanceCliOptions, type X402ProviderAcceptanceCliOutputs, type X402ProviderAcceptanceCliResult, type X402ProviderAcceptanceCliSkip, type X402ProviderAcceptanceError, type X402ProviderAcceptanceGate, type X402ProviderAcceptanceGateOptions, type X402ProviderAcceptanceGateStatus, type X402ProviderAcceptanceOptions, type X402ProviderAcceptanceReport, type X402ProviderAcceptanceReportFormat, type X402ProviderAcceptanceReportOptions, type X402ProviderAcceptanceResult, type X402ProviderAcceptanceStatus, type X402ProviderAcceptanceSummary, type X402ResourceInfo, type X402SandboxPaymentPayload, type X402SandboxPaymentRequirement, type X402SandboxProtocolOptions, type X402SandboxSettlementResponse, type X402SecretRedactionOptions, type X402SettlementResponse, type X402Signer, type X402SignerInput, type X402SignerResult, type X402VerifyResponse, assertJsonSchemaLikeValue, assertProbeMeshAuditTrailBundle, assertProbeMeshCallAuditArtifact, assertProviderCatalog, assertProviderCatalogArtifact, assertProviderCatalogPolicyBundle, assertProviderConformanceArtifact, assertProviderManifest, assertProviderOnboardingDossier, createAdapterFromManifest, createApiKeyProtocol, createHostedCatalogPolicyFromOnboardingDossiers, createHostedRouter, createMockPaymentProtocol, createPaidPriceLookupProvider, createPriceLookupAdapter, createProbeMesh, createProbeMeshAuditTrailBundle, createProbeMeshAuditTrailCollector, createProbeMeshCallAuditArtifact, createProviderCatalog, createProviderCatalogArtifact, createProviderCatalogFromOnboardingDossiers, createProviderCatalogPolicyBundle, createProviderCatalogPolicyReport, createProviderConformanceArtifact, createProviderConformanceReport, createProviderOnboardingDossier, createProviderOnboardingDossierImportReport, createX402EvmSigner, createX402HttpFacilitator, createX402LocalFacilitator, createX402LocalSigner, createX402Protocol, createX402ProviderAcceptanceReport, createX402SandboxProtocol, evaluateProviderCatalogPolicy, evaluateProviderOnboardingDossiers, evaluateX402ProviderAcceptanceGate, findProviderCatalogMatches, findReceiptRef, formatProbeMeshAuditTrailBundle, formatProbeMeshCallAuditArtifact, formatProviderCatalogArtifact, formatProviderCatalogPolicyBundle, formatProviderCatalogPolicyReport, formatProviderConformanceArtifact, formatProviderConformanceReport, formatProviderOnboardingDossier, formatProviderOnboardingDossierImportReport, formatX402ProviderAcceptanceReport, getProbeMeshIntegrationTemplate, getProviderPaymentOptions, getReceiptRefs, hasReceipt, isProbeMeshError, listProbeMeshIntegrationTemplates, mergePaymentPreferences, parseProviderCatalogArtifactJson, parseProviderOnboardingDossierJson, redactX402Secrets, renderProbeMeshIntegrationTemplate, resolveProviderPaymentOption, resolveX402EvmTestnetConfig, runProbeMeshAuditTrailExportCli, runProbeMeshInitCli, runProviderCatalogPolicyCli, runProviderConformance, runProviderConformanceCli, runProviderDossierCheckCli, runProviderOnboardingDossierCli, runX402ProviderAcceptance, runX402ProviderAcceptanceCli, startHostedRouter, summarizeProbeMeshAuditTrailBundle, summarizeProviderCatalog, summarizeReceipts, summarizeX402AcceptanceResult, validateJsonSchemaLikeValue, validatePaymentStrategy, validateProbeMeshAuditTrailBundle, validateProbeMeshCallAuditArtifact, validateProviderCatalog, validateProviderCatalogArtifact, validateProviderCatalogPolicyBundle, validateProviderConformanceArtifact, validateProviderManifest, validateProviderOnboardingDossier, verifyProviderCatalogPolicyBundleRuntime };