@agentcash/discovery 0.1.4 → 1.0.1

package/dist/index.d.ts

@@ -1,5 +1,238 @@
+import { ResultAsync } from 'neverthrow';
 import { CompatibilityMode } from './flags.js';
-export { DEFAULT_COMPAT_MODE, LEGACY_SUNSET_DATE, STRICT_ESCALATION_CODES } from './flags.js';
+
+type TrustTier = 'unverified' | 'origin_hosted' | 'ownership_verified' | 'runtime_verified';
+type AuthMode = 'paid' | 'siwx' | 'apiKey' | 'apiKey+paid' | 'unprotected';
+type PricingMode = 'fixed' | 'range' | 'quote';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE';
+
+interface MppPaymentOption {
+    protocol: 'mpp';
+    /** Payment method identifier, e.g. "tempo" (Tempo protocol). */ paymentMethod: string;
+    /** Payment intent type, e.g. "charge". */
+    intent: string;
+    /** Server protection realm. */
+    realm: string;
+    /** CAIP-2 style network identifier, e.g. "tempo:4217". */ network: string;
+    /** Currency / token contract. */
+    asset: string;
+    /** Raw token-unit amount string. */
+    amount: string;
+    /** Token decimal places, used for display conversion. */
+    decimals?: number;
+    /** Recipient address. */
+    payTo?: string;
+    /** Human-readable description of the resource. */
+    description?: string;
+}
+
+interface X402V1PaymentOption {
+    protocol: 'x402';
+    version: 1;
+    /** Payment scheme, e.g. "exact". */
+    scheme?: string;
+    /** CAIP-2 network identifier, e.g. "eip155:8453". */
+    network: string;
+    /** Token contract address. */
+    asset: string;
+    /** Upper-bound token-unit amount string (v1 semantics). */
+    maxAmountRequired: string;
+    /** Recipient wallet address. */
+    payTo?: string;
+    maxTimeoutSeconds?: number;
+}
+interface X402V2PaymentOption {
+    protocol: 'x402';
+    version: 2;
+    /** Payment scheme, e.g. "exact". */
+    scheme?: string;
+    /** CAIP-2 network identifier, e.g. "eip155:8453". */
+    network: string;
+    /** Token contract address. */
+    asset: string;
+    /** Exact token-unit amount string (v2 semantics). */
+    amount: string;
+    /** Recipient wallet address. */
+    payTo?: string;
+    maxTimeoutSeconds?: number;
+}
+type X402PaymentOption = X402V1PaymentOption | X402V2PaymentOption;
+type PaymentOption = X402PaymentOption | MppPaymentOption;
+interface PricingHint {
+    pricingMode: PricingMode;
+    price?: string;
+    minPrice?: string;
+    maxPrice?: string;
+}
+interface OpenApiSource {
+    raw: Record<string, unknown>;
+    info: {
+        title: string;
+        description?: string;
+        version: string;
+    };
+    routes: OpenApiRoute[];
+    /** Inline guidance text from `info.guidance` — no fetch needed. Happy path for L4. */
+    guidance?: string;
+    fetchedUrl: string;
+}
+interface OpenApiRoute {
+    path: string;
+    method: HttpMethod;
+    summary?: string;
+    authMode?: AuthMode;
+    protocols?: string[];
+    pricing?: PricingHint;
+}
+interface WellKnownSource {
+    raw: Record<string, unknown>;
+    routes: WellKnownRoute[];
+    instructions?: string;
+    fetchedUrl: string;
+}
+interface WellKnownRoute {
+    path: string;
+    method: HttpMethod;
+}
+interface ProbeResult {
+    path: string;
+    method: HttpMethod;
+    authHint: AuthMode;
+    protocols?: string[];
+    /** Raw 402 response body, present when the endpoint returned a payment challenge. */
+    paymentRequiredBody?: unknown;
+    /** Raw WWW-Authenticate header value from the 402 response. */
+    wwwAuthenticate?: string;
+}
+interface L2Result {
+    title?: string;
+    description?: string;
+    routes: L2Route[];
+    source: 'openapi' | 'well-known/x402' | null;
+}
+interface L2Route {
+    path: string;
+    method: HttpMethod;
+    summary: string;
+    authMode?: AuthMode;
+    price?: string;
+    protocols?: string[];
+}
+interface L3Result {
+    source: 'openapi' | 'probe';
+    summary?: string;
+    authMode?: AuthMode;
+    estimatedPrice?: string;
+    protocols?: string[];
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    /** Live payment options parsed from the 402 response. Only present on probe results. */
+    paymentOptions?: PaymentOption[];
+}
+interface L4Result {
+    guidance: string;
+    source: 'openapi' | 'well-known/x402';
+}
+
+declare enum GuidanceMode {
+    /** Include guidance only when under the auto-include threshold (default). */
+    Auto = "auto",
+    /** Always include guidance, even if large. */
+    Always = "always",
+    /** Never include guidance; return discovery data only. */
+    Never = "never"
+}
+interface DiscoverOriginSchemaOptions {
+    target: string;
+    guidance?: GuidanceMode;
+    specificationOverrideUrl?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+interface DiscoverOriginSchemaSuccess {
+    found: true;
+    origin: string;
+    /** Which discovery context source produced the endpoint list (e.g. `"openapi"`). */
+    source: string;
+    /** Metadata from the OpenAPI `info` block, when available. */
+    info?: {
+        title: string;
+        description?: string;
+    };
+    /** Discovered endpoints with advisory pricing and auth metadata. */
+    endpoints: L2Route[];
+    /** True when guidance text exists for this API. */
+    guidanceAvailable: boolean;
+    /** Estimated token count of the guidance text. Present when guidanceAvailable is true. */
+    guidanceTokens?: number;
+    /** Guidance text. Included when short enough (auto mode) or guidance='always'. */
+    guidance?: string;
+}
+interface DiscoverOriginSchemaNotFound {
+    found: false;
+    origin: string;
+    cause: 'not_found' | 'network' | 'timeout';
+    message?: string;
+}
+type DiscoverOriginSchemaResult = DiscoverOriginSchemaSuccess | DiscoverOriginSchemaNotFound;
+interface CheckEndpointOptions {
+    /** Full endpoint URL (e.g. `"https://api.example.com/pay"`). */
+    url: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    /** Sample input body for the endpoint.
+     *
+     * Providing this will cause the endpoint to always be probed, and will return the exact
+     * PaymentOptions that would be returned by the live 402 response.
+     *
+     * The agent will use this to get an exact price quote for the body they are planning on sending
+     * with fetch.
+     *
+     */
+    sampleInputBody?: Record<string, unknown>;
+}
+interface EndpointMethodAdvisory extends L3Result {
+    method: HttpMethod;
+}
+interface CheckEndpointSuccess {
+    found: true;
+    origin: string;
+    path: string;
+    advisories: EndpointMethodAdvisory[];
+}
+interface CheckEndpointNotFound {
+    found: false;
+    origin: string;
+    path: string;
+    cause: 'not_found' | 'network' | 'timeout';
+    message?: string;
+}
+type CheckEndpointResult = CheckEndpointSuccess | CheckEndpointNotFound;
+
+declare function discoverOriginSchema(options: DiscoverOriginSchemaOptions): Promise<DiscoverOriginSchemaResult>;
+
+declare function checkEndpointSchema(options: CheckEndpointOptions): Promise<CheckEndpointResult>;
+
+interface FetchError {
+    cause: 'network' | 'timeout';
+    message: string;
+}
+
+declare function getOpenAPI(origin: string, headers?: Record<string, string>, signal?: AbortSignal, specificationOverrideUrl?: string): ResultAsync<OpenApiSource | null, FetchError>;
+
+declare function getWellKnown(origin: string, headers?: Record<string, string>, signal?: AbortSignal): ResultAsync<WellKnownSource | null, FetchError>;
+
+declare function getProbe(url: string, headers?: Record<string, string>, signal?: AbortSignal, inputBody?: Record<string, unknown>): ResultAsync<ProbeResult[], FetchError>;
+
+declare function checkL2ForOpenAPI(openApi: OpenApiSource): L2Result;
+declare function checkL2ForWellknown(wellKnown: WellKnownSource): L2Result;
+
+declare function getL3ForOpenAPI(openApi: OpenApiSource, path: string, method: HttpMethod): L3Result | null;
+declare function getL3ForProbe(probe: ProbeResult[], path: string, method: HttpMethod): L3Result | null;
+declare function getL3(openApi: OpenApiSource | null, probe: ProbeResult[], path: string, method: HttpMethod): L3Result | null;
+
+declare function checkL4ForOpenAPI(openApi: OpenApiSource): L4Result | null;
+declare function checkL4ForWellknown(wellKnown: WellKnownSource): L4Result | null;
 
 declare const VALIDATION_CODES: {
     readonly COINBASE_SCHEMA_INVALID: "COINBASE_SCHEMA_INVALID";
@@ -85,292 +318,38 @@ declare function evaluateMetadataCompleteness(metadata: MetadataPreview): Valida
 
 declare function validatePaymentRequiredDetailed(payload: unknown, options?: ValidatePaymentRequiredOptions): ValidatePaymentRequiredDetailedResult;
 
-type DiscoveryStage = 'override' | 'openapi' | 'well-known/x402' | 'dns/_x402' | 'interop/mpp' | 'probe';
-type WarningSeverity = 'error' | 'warn' | 'info';
-type TrustTier = 'unverified' | 'origin_hosted' | 'ownership_verified' | 'runtime_verified';
-type AuthMode = 'paid' | 'siwx' | 'apiKey' | 'unprotected';
-type PricingMode = 'fixed' | 'range' | 'quote';
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE';
-interface DiscoveryWarning {
+declare const AUDIT_CODES: {
+    readonly OPENAPI_NOT_FOUND: "OPENAPI_NOT_FOUND";
+    readonly WELLKNOWN_NOT_FOUND: "WELLKNOWN_NOT_FOUND";
+    readonly OPENAPI_NO_ROUTES: "OPENAPI_NO_ROUTES";
+    readonly L2_NO_ROUTES: "L2_NO_ROUTES";
+    readonly L2_ROUTE_COUNT_HIGH: "L2_ROUTE_COUNT_HIGH";
+    readonly L2_AUTH_MODE_MISSING: "L2_AUTH_MODE_MISSING";
+    readonly L2_PRICE_MISSING_ON_PAID: "L2_PRICE_MISSING_ON_PAID";
+    readonly L2_PROTOCOLS_MISSING_ON_PAID: "L2_PROTOCOLS_MISSING_ON_PAID";
+    readonly L3_NOT_FOUND: "L3_NOT_FOUND";
+    readonly L3_INPUT_SCHEMA_MISSING: "L3_INPUT_SCHEMA_MISSING";
+    readonly L3_AUTH_MODE_MISSING: "L3_AUTH_MODE_MISSING";
+    readonly L3_PROTOCOLS_MISSING_ON_PAID: "L3_PROTOCOLS_MISSING_ON_PAID";
+    readonly L4_GUIDANCE_MISSING: "L4_GUIDANCE_MISSING";
+    readonly L4_GUIDANCE_TOO_LONG: "L4_GUIDANCE_TOO_LONG";
+};
+type AuditCode = (typeof AUDIT_CODES)[keyof typeof AUDIT_CODES];
+
+type AuditSeverity = 'error' | 'warn' | 'info';
+interface AuditWarning {
     code: string;
-    severity: WarningSeverity;
+    severity: AuditSeverity;
     message: string;
     hint?: string;
-    stage?: DiscoveryStage;
-    resourceKey?: string;
-}
-interface PricingHint {
-    pricingMode: PricingMode;
-    price?: string;
-    minPrice?: string;
-    maxPrice?: string;
-}
-interface ResourceLinks {
-    openapiUrl?: string;
-    wellKnownUrl?: string;
-    discoveryUrl?: string;
-    llmsTxtUrl?: string;
-}
-interface DiscoveryResource {
-    resourceKey: string;
-    origin: string;
-    method: HttpMethod;
-    path: string;
-    source: DiscoveryStage;
-    verified: boolean;
-    protocolHints?: string[];
-    priceHint?: string;
-    pricing?: PricingHint;
-    authHint?: AuthMode;
-    summary?: string;
-    confidence?: number;
-    trustTier?: TrustTier;
-    links?: ResourceLinks;
-}
-interface StageTrace {
-    stage: DiscoveryStage;
-    attempted: boolean;
-    valid: boolean;
-    resourceCount: number;
-    durationMs: number;
-    warnings: DiscoveryWarning[];
-    links?: ResourceLinks;
-}
-interface RawSources {
-    openapi?: unknown;
-    llmsTxt?: string;
-    wellKnownX402?: unknown[];
-    dnsRecords?: string[];
-    interopMpp?: unknown;
-}
-interface DiscoverResult {
-    origin: string;
-    resources: DiscoveryResource[];
-    warnings: DiscoveryWarning[];
-    compatMode: CompatibilityMode;
-    upgradeSuggested: boolean;
-    upgradeReasons: string[];
-    selectedStage?: DiscoveryStage;
-}
-interface DiscoverDetailedResult extends DiscoverResult {
-    trace: StageTrace[];
-    resourceWarnings: Record<string, DiscoveryWarning[]>;
-    rawSources?: RawSources;
-}
-type DiscoveryFetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-type TxtResolver = (fqdn: string) => Promise<string[]>;
-interface ProbeCandidate {
-    path: string;
-    methods?: HttpMethod[];
-}
-interface DiscoverOptions {
-    target: string;
-    compatMode?: CompatibilityMode;
-    overrideUrls?: string[];
-    fetcher?: DiscoveryFetcher;
-    txtResolver?: TxtResolver;
-    probeCandidates?: ProbeCandidate[];
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-}
-interface DiscoverDetailedOptions extends DiscoverOptions {
-    rawView?: 'none' | 'full';
-    includeInteropMpp?: boolean;
-}
-
-type McpFailureCause = 'not_found' | 'network' | 'timeout' | 'parse';
-type McpAuthMode = 'paid' | 'siwx' | 'apiKey' | 'unprotected';
-interface McpOpenApiInfo {
-    title: string;
-    version?: string;
-    description?: string;
-}
-interface McpEndpointSummary {
-    path: string;
-    method: HttpMethod;
-    summary: string;
-    price?: string;
-    protocols?: string[];
-    authMode?: McpAuthMode;
-}
-interface McpGuidance {
-    guidanceAvailable: boolean;
-    guidanceTokens?: number;
-    guidance?: string;
-}
-interface DiscoverForMcpOptions {
-    target: string;
-    includeGuidance?: boolean;
-    guidanceAutoIncludeMaxTokens?: number;
-    compatMode?: CompatibilityMode;
-    fetcher?: DiscoveryFetcher;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-}
-interface DiscoverForMcpSuccess extends McpGuidance {
-    found: true;
-    origin: string;
-    source: string;
-    info?: McpOpenApiInfo;
-    endpoints: McpEndpointSummary[];
-    warnings: DiscoveryWarning[];
-}
-interface DiscoverForMcpFailure {
-    found: false;
-    origin: string;
-    cause: McpFailureCause;
-    message?: string;
-    warnings: DiscoveryWarning[];
-}
-type DiscoverForMcpResult = DiscoverForMcpSuccess | DiscoverForMcpFailure;
-interface EndpointMethodAdvisory {
-    method: HttpMethod;
-    summary?: string;
-    estimatedPrice?: string;
-    protocols?: string[];
-    authMode?: McpAuthMode;
-    inputSchema?: Record<string, unknown>;
-    operationSchema?: Record<string, unknown>;
-}
-interface InspectEndpointForMcpOptions {
-    target: string;
-    endpointUrl: string;
-    compatMode?: CompatibilityMode;
-    fetcher?: DiscoveryFetcher;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-}
-interface InspectEndpointForMcpSuccess {
-    found: true;
-    origin: string;
-    path: string;
-    specMethods: HttpMethod[];
-    advisories: Partial<Record<HttpMethod, EndpointMethodAdvisory>>;
-    warnings: DiscoveryWarning[];
-}
-interface InspectEndpointForMcpFailure {
-    found: false;
-    origin: string;
-    path: string;
-    cause: McpFailureCause;
-    message?: string;
-    warnings: DiscoveryWarning[];
-}
-type InspectEndpointForMcpResult = InspectEndpointForMcpSuccess | InspectEndpointForMcpFailure;
-declare function discoverForMcp(options: DiscoverForMcpOptions): Promise<DiscoverForMcpResult>;
-declare function inspectEndpointForMcp(options: InspectEndpointForMcpOptions): Promise<InspectEndpointForMcpResult>;
-
-declare const UPGRADE_WARNING_CODES: readonly ["LEGACY_WELL_KNOWN_USED", "LEGACY_DNS_USED", "LEGACY_DNS_PLAIN_URL", "LEGACY_INSTRUCTIONS_USED", "LEGACY_OWNERSHIP_PROOFS_USED", "OPENAPI_AUTH_MODE_MISSING", "OPENAPI_TOP_LEVEL_INVALID"];
-declare function computeUpgradeSignal(warnings: DiscoveryWarning[]): {
-    upgradeSuggested: boolean;
-    upgradeReasons: string[];
-};
-
-type HarnessClientId = 'claude-code' | 'skill-cli' | 'generic-mcp' | 'generic';
-interface HarnessClientProfile {
-    id: HarnessClientId;
-    label: string;
-    surface: 'mcp' | 'skill-cli' | 'generic';
-    defaultContextWindowTokens: number;
-    zeroHopBudgetPercent: number;
-    notes: string;
-}
-interface ContextHarnessL0 {
-    layer: 'L0';
-    intentTriggers: string[];
-    installCommand: string;
-    deliverySurfaces: string[];
-    summary: string;
-    estimatedTokens: number;
-}
-interface ContextHarnessL1 {
-    layer: 'L1';
-    domain: string;
-    domainClass: 'first-party' | 'ugc';
-    selectedDiscoveryStage: DiscoverResult['selectedStage'] | null;
-    summary: string;
-    fanoutCommands: string[];
-    estimatedTokens: number;
-}
-interface ContextHarnessL2Entry {
-    resourceKey: string;
-    method: DiscoveryResource['method'];
-    path: string;
-    source: DiscoveryResource['source'];
-    authMode: DiscoveryResource['authHint'] | null;
-}
-interface ContextHarnessL2 {
-    layer: 'L2';
-    command: string;
-    tokenLight: boolean;
-    resourceCount: number;
-    resources: ContextHarnessL2Entry[];
-}
-interface ContextHarnessL3 {
-    layer: 'L3';
-    command: string;
-    detailLevel: 'endpoint-schema-and-metadata';
-    countsByAuthMode: Record<'paid' | 'siwx' | 'apiKey' | 'unprotected' | 'unknown', number>;
-    countsBySource: Record<string, number>;
-    pricedResourceCount: number;
-}
-interface ContextHarnessL4 {
-    layer: 'L4';
-    guidanceSource: 'llms.txt' | 'none';
-    llmsTxtUrl: string | null;
-    llmsTxtTokenEstimate: number;
-    guidancePreview: string | null;
-    guidanceStatus: 'present' | 'advertised_but_unfetched' | 'missing' | 'not_advertised';
-}
-interface ContextHarnessL5 {
-    layer: 'L5';
-    status: 'out_of_scope';
-    note: string;
-}
-interface ContextHarnessBudget {
-    contextWindowTokens: number;
-    zeroHopBudgetTokens: number;
-    estimatedZeroHopTokens: number;
-    withinBudget: boolean;
-}
-interface ContextHarnessReport {
-    target: string;
-    origin: string;
-    client: HarnessClientProfile;
-    budget: ContextHarnessBudget;
-    levels: {
-        l0: ContextHarnessL0;
-        l1: ContextHarnessL1;
-        l2: ContextHarnessL2;
-        l3: ContextHarnessL3;
-        l4: ContextHarnessL4;
-        l5: ContextHarnessL5;
-    };
-    diagnostics: {
-        warningCount: number;
-        errorWarningCount: number;
-        selectedStage: DiscoverResult['selectedStage'] | null;
-        upgradeSuggested: boolean;
-        upgradeReasons: string[];
-    };
-}
-interface BuildContextHarnessReportOptions {
-    target: string;
-    result: DiscoverDetailedResult;
-    client?: HarnessClientId;
-    contextWindowTokens?: number;
-}
-interface AuditContextHarnessOptions extends Omit<DiscoverDetailedOptions, 'rawView'> {
-    client?: HarnessClientId;
-    contextWindowTokens?: number;
+    /** Dotted path to the field this warning refers to, when applicable. */
+    path?: string;
 }
-declare function getHarnessClientProfile(client?: HarnessClientId): HarnessClientProfile;
-declare function listHarnessClientProfiles(): HarnessClientProfile[];
-declare function buildContextHarnessReport(options: BuildContextHarnessReportOptions): ContextHarnessReport;
-declare function auditContextHarness(options: AuditContextHarnessOptions): Promise<ContextHarnessReport>;
-declare function defaultHarnessProbeCandidates(report: ContextHarnessReport): ProbeCandidate[];
 
-declare function discover(options: DiscoverOptions): Promise<DiscoverResult>;
-declare function discoverDetailed(options: DiscoverDetailedOptions): Promise<DiscoverDetailedResult>;
+declare function getWarningsForOpenAPI(openApi: OpenApiSource | null): AuditWarning[];
+declare function getWarningsForWellKnown(wellKnown: WellKnownSource | null): AuditWarning[];
+declare function getWarningsForL2(l2: L2Result): AuditWarning[];
+declare function getWarningsForL3(l3: L3Result | null): AuditWarning[];
+declare function getWarningsForL4(l4: L4Result | null): AuditWarning[];
 
-export { type AuthMode, CompatibilityMode, type ContextHarnessL0, type ContextHarnessL1, type ContextHarnessL2, type ContextHarnessL2Entry, type ContextHarnessL3, type ContextHarnessL4, type ContextHarnessL5, type ContextHarnessReport, type DiscoverDetailedOptions, type DiscoverDetailedResult, type DiscoverForMcpFailure, type DiscoverForMcpOptions, type DiscoverForMcpResult, type DiscoverForMcpSuccess, type DiscoverOptions, type DiscoverResult, type DiscoveryFetcher, type DiscoveryResource, type DiscoveryStage, type DiscoveryWarning, type EndpointMethodAdvisory, type HarnessClientId, type HarnessClientProfile, type HttpMethod, type InspectEndpointForMcpFailure, type InspectEndpointForMcpOptions, type InspectEndpointForMcpResult, type InspectEndpointForMcpSuccess, type MetadataPreview, type NormalizedAccept, type NormalizedPaymentRequired, type PricingMode, type ProbeCandidate, type RawSources, type StageTrace, type TrustTier, type TxtResolver, UPGRADE_WARNING_CODES, VALIDATION_CODES, type ValidatePaymentRequiredDetailedResult, type ValidatePaymentRequiredOptions, type ValidationIssue, type ValidationSeverity, type ValidationStage, type ValidationSummary, type WarningSeverity, auditContextHarness, buildContextHarnessReport, computeUpgradeSignal, defaultHarnessProbeCandidates, discover, discoverDetailed, discoverForMcp, evaluateMetadataCompleteness, getHarnessClientProfile, inspectEndpointForMcp, listHarnessClientProfiles, validatePaymentRequiredDetailed };
+export { AUDIT_CODES, type AuditCode, type AuditSeverity, type AuditWarning, type AuthMode, type CheckEndpointNotFound, type CheckEndpointOptions, type CheckEndpointResult, type CheckEndpointSuccess, type DiscoverOriginSchemaNotFound, type DiscoverOriginSchemaOptions, type DiscoverOriginSchemaResult, type DiscoverOriginSchemaSuccess, type EndpointMethodAdvisory, GuidanceMode, type HttpMethod, type L2Result, type L2Route, type L3Result, type L4Result, type MetadataPreview, type MppPaymentOption, type NormalizedAccept, type NormalizedPaymentRequired, type OpenApiRoute, type OpenApiSource, type PaymentOption, type PricingMode, type ProbeResult, type TrustTier, VALIDATION_CODES, type ValidatePaymentRequiredDetailedResult, type ValidatePaymentRequiredOptions, type ValidationIssue, type ValidationSeverity, type ValidationStage, type ValidationSummary, type WellKnownRoute, type WellKnownSource, type X402PaymentOption, type X402V1PaymentOption, type X402V2PaymentOption, checkEndpointSchema, checkL2ForOpenAPI, checkL2ForWellknown, checkL4ForOpenAPI, checkL4ForWellknown, discoverOriginSchema, evaluateMetadataCompleteness, getL3, getL3ForOpenAPI, getL3ForProbe, getOpenAPI, getProbe, getWarningsForL2, getWarningsForL3, getWarningsForL4, getWarningsForOpenAPI, getWarningsForWellKnown, getWellKnown, validatePaymentRequiredDetailed };