x402-core-mantle 2.1.1-mantle

package/dist/cjs/x402HTTPResourceServer-D1YtlH_r.d.ts

@@ -0,0 +1,719 @@
+import { P as PaymentPayload, a as PaymentRequirements, V as VerifyResponse, S as SettleResponse, e as SupportedResponse, N as Network, f as SchemeNetworkServer, R as ResourceServerExtension, g as SupportedKind, h as Price, c as PaymentRequired } from './mechanisms-CzuGzYsS.js';
+
+interface FacilitatorConfig {
+    url?: string;
+    createAuthHeaders?: () => Promise<{
+        verify: Record<string, string>;
+        settle: Record<string, string>;
+        supported: Record<string, string>;
+    }>;
+}
+/**
+ * Interface for facilitator clients
+ * Can be implemented for HTTP-based or local facilitators
+ */
+interface FacilitatorClient {
+    /**
+     * Verify a payment with the facilitator
+     *
+     * @param paymentPayload - The payment to verify
+     * @param paymentRequirements - The requirements to verify against
+     * @returns Verification response
+     */
+    verify(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settle a payment with the facilitator
+     *
+     * @param paymentPayload - The payment to settle
+     * @param paymentRequirements - The requirements for settlement
+     * @returns Settlement response
+     */
+    settle(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Get supported payment kinds and extensions from the facilitator
+     *
+     * @returns Supported payment kinds and extensions
+     */
+    getSupported(): Promise<SupportedResponse>;
+}
+/**
+ * HTTP-based client for interacting with x402 facilitator services
+ * Handles HTTP communication with facilitator endpoints
+ */
+declare class HTTPFacilitatorClient implements FacilitatorClient {
+    readonly url: string;
+    private readonly _createAuthHeaders?;
+    /**
+     * Creates a new HTTPFacilitatorClient instance.
+     *
+     * @param config - Configuration options for the facilitator client
+     */
+    constructor(config?: FacilitatorConfig);
+    /**
+     * Verify a payment with the facilitator
+     *
+     * @param paymentPayload - The payment to verify
+     * @param paymentRequirements - The requirements to verify against
+     * @returns Verification response
+     */
+    verify(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settle a payment with the facilitator
+     *
+     * @param paymentPayload - The payment to settle
+     * @param paymentRequirements - The requirements for settlement
+     * @returns Settlement response
+     */
+    settle(paymentPayload: PaymentPayload, paymentRequirements: PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Get supported payment kinds and extensions from the facilitator
+     *
+     * @returns Supported payment kinds and extensions
+     */
+    getSupported(): Promise<SupportedResponse>;
+    /**
+     * Creates authentication headers for a specific path.
+     *
+     * @param path - The path to create authentication headers for (e.g., "verify", "settle", "supported")
+     * @returns An object containing the authentication headers for the specified path
+     */
+    createAuthHeaders(path: string): Promise<{
+        headers: Record<string, string>;
+    }>;
+    /**
+     * Helper to convert objects to JSON-safe format.
+     * Handles BigInt and other non-JSON types.
+     *
+     * @param obj - The object to convert
+     * @returns The JSON-safe representation of the object
+     */
+    private toJsonSafe;
+}
+
+/**
+ * Configuration for a protected resource
+ * Only contains payment-specific configuration, not resource metadata
+ */
+interface ResourceConfig {
+    scheme: string;
+    payTo: string;
+    price: Price;
+    network: Network;
+    maxTimeoutSeconds?: number;
+}
+/**
+ * Resource information for PaymentRequired response
+ */
+interface ResourceInfo {
+    url: string;
+    description: string;
+    mimeType: string;
+}
+/**
+ * Lifecycle Hook Context Interfaces
+ */
+interface VerifyContext {
+    paymentPayload: PaymentPayload;
+    requirements: PaymentRequirements;
+}
+interface VerifyResultContext extends VerifyContext {
+    result: VerifyResponse;
+}
+interface VerifyFailureContext extends VerifyContext {
+    error: Error;
+}
+interface SettleContext {
+    paymentPayload: PaymentPayload;
+    requirements: PaymentRequirements;
+}
+interface SettleResultContext extends SettleContext {
+    result: SettleResponse;
+}
+interface SettleFailureContext extends SettleContext {
+    error: Error;
+}
+/**
+ * Lifecycle Hook Type Definitions
+ */
+type BeforeVerifyHook = (context: VerifyContext) => Promise<void | {
+    abort: true;
+    reason: string;
+}>;
+type AfterVerifyHook = (context: VerifyResultContext) => Promise<void>;
+type OnVerifyFailureHook = (context: VerifyFailureContext) => Promise<void | {
+    recovered: true;
+    result: VerifyResponse;
+}>;
+type BeforeSettleHook = (context: SettleContext) => Promise<void | {
+    abort: true;
+    reason: string;
+}>;
+type AfterSettleHook = (context: SettleResultContext) => Promise<void>;
+type OnSettleFailureHook = (context: SettleFailureContext) => Promise<void | {
+    recovered: true;
+    result: SettleResponse;
+}>;
+/**
+ * Core x402 protocol server for resource protection
+ * Transport-agnostic implementation of the x402 payment protocol
+ */
+declare class x402ResourceServer {
+    private facilitatorClients;
+    private registeredServerSchemes;
+    private supportedResponsesMap;
+    private facilitatorClientsMap;
+    private registeredExtensions;
+    private beforeVerifyHooks;
+    private afterVerifyHooks;
+    private onVerifyFailureHooks;
+    private beforeSettleHooks;
+    private afterSettleHooks;
+    private onSettleFailureHooks;
+    /**
+     * Creates a new x402ResourceServer instance.
+     *
+     * @param facilitatorClients - Optional facilitator client(s) for payment processing
+     */
+    constructor(facilitatorClients?: FacilitatorClient | FacilitatorClient[]);
+    /**
+     * Register a scheme/network server implementation.
+     *
+     * @param network - The network identifier
+     * @param server - The scheme/network server implementation
+     * @returns The x402ResourceServer instance for chaining
+     */
+    register(network: Network, server: SchemeNetworkServer): x402ResourceServer;
+    /**
+     * Check if a scheme is registered for a given network.
+     *
+     * @param network - The network identifier
+     * @param scheme - The payment scheme name
+     * @returns True if the scheme is registered for the network, false otherwise
+     */
+    hasRegisteredScheme(network: Network, scheme: string): boolean;
+    /**
+     * Registers a resource service extension that can enrich extension declarations.
+     *
+     * @param extension - The extension to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    registerExtension(extension: ResourceServerExtension): this;
+    /**
+     * Enriches declared extensions using registered extension hooks.
+     *
+     * @param declaredExtensions - Extensions declared on the route
+     * @param transportContext - Transport-specific context (HTTP, A2A, MCP, etc.)
+     * @returns Enriched extensions map
+     */
+    enrichExtensions(declaredExtensions: Record<string, unknown>, transportContext: unknown): Record<string, unknown>;
+    /**
+     * Register a hook to execute before payment verification.
+     * Can abort verification by returning { abort: true, reason: string }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    onBeforeVerify(hook: BeforeVerifyHook): x402ResourceServer;
+    /**
+     * Register a hook to execute after successful payment verification.
+     *
+     * @param hook - The hook function to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    onAfterVerify(hook: AfterVerifyHook): x402ResourceServer;
+    /**
+     * Register a hook to execute when payment verification fails.
+     * Can recover from failure by returning { recovered: true, result: VerifyResponse }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    onVerifyFailure(hook: OnVerifyFailureHook): x402ResourceServer;
+    /**
+     * Register a hook to execute before payment settlement.
+     * Can abort settlement by returning { abort: true, reason: string }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    onBeforeSettle(hook: BeforeSettleHook): x402ResourceServer;
+    /**
+     * Register a hook to execute after successful payment settlement.
+     *
+     * @param hook - The hook function to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    onAfterSettle(hook: AfterSettleHook): x402ResourceServer;
+    /**
+     * Register a hook to execute when payment settlement fails.
+     * Can recover from failure by returning { recovered: true, result: SettleResponse }
+     *
+     * @param hook - The hook function to register
+     * @returns The x402ResourceServer instance for chaining
+     */
+    onSettleFailure(hook: OnSettleFailureHook): x402ResourceServer;
+    /**
+     * Initialize by fetching supported kinds from all facilitators
+     * Creates mappings for supported responses and facilitator clients
+     * Earlier facilitators in the array get precedence
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get supported kind for a specific version, network, and scheme
+     *
+     * @param x402Version - The x402 version
+     * @param network - The network identifier
+     * @param scheme - The payment scheme
+     * @returns The supported kind or undefined if not found
+     */
+    getSupportedKind(x402Version: number, network: Network, scheme: string): SupportedKind | undefined;
+    /**
+     * Get facilitator extensions for a specific version, network, and scheme
+     *
+     * @param x402Version - The x402 version
+     * @param network - The network identifier
+     * @param scheme - The payment scheme
+     * @returns The facilitator extensions or empty array if not found
+     */
+    getFacilitatorExtensions(x402Version: number, network: Network, scheme: string): string[];
+    /**
+     * Build payment requirements for a protected resource
+     *
+     * @param resourceConfig - Configuration for the protected resource
+     * @returns Array of payment requirements
+     */
+    buildPaymentRequirements(resourceConfig: ResourceConfig): Promise<PaymentRequirements[]>;
+    /**
+     * Build payment requirements from multiple payment options
+     * This method handles resolving dynamic payTo/price functions and builds requirements for each option
+     *
+     * @param paymentOptions - Array of payment options to convert
+     * @param context - HTTP request context for resolving dynamic functions
+     * @returns Array of payment requirements (one per option)
+     */
+    buildPaymentRequirementsFromOptions<TContext = unknown>(paymentOptions: Array<{
+        scheme: string;
+        payTo: string | ((context: TContext) => string | Promise<string>);
+        price: Price | ((context: TContext) => Price | Promise<Price>);
+        network: Network;
+        maxTimeoutSeconds?: number;
+    }>, context: TContext): Promise<PaymentRequirements[]>;
+    /**
+     * Create a payment required response
+     *
+     * @param requirements - Payment requirements
+     * @param resourceInfo - Resource information
+     * @param error - Error message
+     * @param extensions - Optional extensions
+     * @returns Payment required response object
+     */
+    createPaymentRequiredResponse(requirements: PaymentRequirements[], resourceInfo: ResourceInfo, error?: string, extensions?: Record<string, unknown>): PaymentRequired;
+    /**
+     * Verify a payment against requirements
+     *
+     * @param paymentPayload - The payment payload to verify
+     * @param requirements - The payment requirements
+     * @returns Verification response
+     */
+    verifyPayment(paymentPayload: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    /**
+     * Settle a verified payment
+     *
+     * @param paymentPayload - The payment payload to settle
+     * @param requirements - The payment requirements
+     * @returns Settlement response
+     */
+    settlePayment(paymentPayload: PaymentPayload, requirements: PaymentRequirements): Promise<SettleResponse>;
+    /**
+     * Find matching payment requirements for a payment
+     *
+     * @param availableRequirements - Array of available payment requirements
+     * @param paymentPayload - The payment payload
+     * @returns Matching payment requirements or undefined
+     */
+    findMatchingRequirements(availableRequirements: PaymentRequirements[], paymentPayload: PaymentPayload): PaymentRequirements | undefined;
+    /**
+     * Process a payment request
+     *
+     * @param paymentPayload - Optional payment payload if provided
+     * @param resourceConfig - Configuration for the protected resource
+     * @param resourceInfo - Information about the resource being accessed
+     * @param extensions - Optional extensions to include in the response
+     * @returns Processing result
+     */
+    processPaymentRequest(paymentPayload: PaymentPayload | null, resourceConfig: ResourceConfig, resourceInfo: ResourceInfo, extensions?: Record<string, unknown>): Promise<{
+        success: boolean;
+        requiresPayment?: PaymentRequired;
+        verificationResult?: VerifyResponse;
+        settlementResult?: SettleResponse;
+        error?: string;
+    }>;
+    /**
+     * Get facilitator client for a specific version, network, and scheme
+     *
+     * @param x402Version - The x402 version
+     * @param network - The network identifier
+     * @param scheme - The payment scheme
+     * @returns The facilitator client or undefined if not found
+     */
+    private getFacilitatorClient;
+}
+
+/**
+ * Framework-agnostic HTTP adapter interface
+ * Implementations provide framework-specific HTTP operations
+ */
+interface HTTPAdapter {
+    getHeader(name: string): string | undefined;
+    getMethod(): string;
+    getPath(): string;
+    getUrl(): string;
+    getAcceptHeader(): string;
+    getUserAgent(): string;
+    /**
+     * Get query parameters from the request URL
+     *
+     * @returns Record of query parameter key-value pairs
+     */
+    getQueryParams?(): Record<string, string | string[]>;
+    /**
+     * Get a specific query parameter by name
+     *
+     * @param name - The query parameter name
+     * @returns The query parameter value(s) or undefined
+     */
+    getQueryParam?(name: string): string | string[] | undefined;
+    /**
+     * Get the parsed request body
+     * Framework adapters should parse JSON/form data appropriately
+     *
+     * @returns The parsed request body
+     */
+    getBody?(): unknown;
+}
+/**
+ * Paywall configuration for HTML responses
+ */
+interface PaywallConfig {
+    appName?: string;
+    appLogo?: string;
+    sessionTokenEndpoint?: string;
+    currentUrl?: string;
+    testnet?: boolean;
+}
+/**
+ * Paywall provider interface for generating HTML
+ */
+interface PaywallProvider {
+    generateHtml(paymentRequired: PaymentRequired, config?: PaywallConfig): string;
+}
+/**
+ * Dynamic payTo function that receives HTTP request context
+ */
+type DynamicPayTo = (context: HTTPRequestContext) => string | Promise<string>;
+/**
+ * Dynamic price function that receives HTTP request context
+ */
+type DynamicPrice = (context: HTTPRequestContext) => Price | Promise<Price>;
+/**
+ * Result of the unpaid response callback containing content type and body.
+ */
+interface UnpaidResponseResult {
+    /**
+     * The content type for the response (e.g., 'application/json', 'text/plain').
+     */
+    contentType: string;
+    /**
+     * The response body to include in the 402 response.
+     */
+    body: unknown;
+}
+/**
+ * Dynamic function to generate a custom response for unpaid requests.
+ * Receives the HTTP request context and returns the content type and body to include in the 402 response.
+ */
+type UnpaidResponseBody = (context: HTTPRequestContext) => UnpaidResponseResult | Promise<UnpaidResponseResult>;
+/**
+ * A single payment option for a route
+ * Represents one way a client can pay for access to the resource
+ */
+interface PaymentOption {
+    scheme: string;
+    payTo: string | DynamicPayTo;
+    price: Price | DynamicPrice;
+    network: Network;
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+}
+/**
+ * Route configuration for HTTP endpoints
+ *
+ * The 'accepts' field defines payment options for the route.
+ * Can be a single PaymentOption or an array of PaymentOptions for multiple payment methods.
+ */
+interface RouteConfig {
+    accepts: PaymentOption | PaymentOption[];
+    resource?: string;
+    description?: string;
+    mimeType?: string;
+    customPaywallHtml?: string;
+    /**
+     * Optional callback to generate a custom response for unpaid API requests.
+     * This allows servers to return preview data, error messages, or other content
+     * when a request lacks payment.
+     *
+     * For browser requests (Accept: text/html), the paywall HTML takes precedence.
+     * This callback is only used for API clients.
+     *
+     * If not provided, defaults to { contentType: 'application/json', body: {} }.
+     *
+     * @param context - The HTTP request context
+     * @returns An object containing both contentType and body for the 402 response
+     */
+    unpaidResponseBody?: UnpaidResponseBody;
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Routes configuration - maps path patterns to route configs
+ */
+type RoutesConfig = Record<string, RouteConfig> | RouteConfig;
+/**
+ * Compiled route for efficient matching
+ */
+interface CompiledRoute {
+    verb: string;
+    regex: RegExp;
+    config: RouteConfig;
+}
+/**
+ * HTTP request context that encapsulates all request data
+ */
+interface HTTPRequestContext {
+    adapter: HTTPAdapter;
+    path: string;
+    method: string;
+    paymentHeader?: string;
+}
+/**
+ * HTTP response instructions for the framework middleware
+ */
+interface HTTPResponseInstructions {
+    status: number;
+    headers: Record<string, string>;
+    body?: unknown;
+    isHtml?: boolean;
+}
+/**
+ * Result of processing an HTTP request for payment
+ */
+type HTTPProcessResult = {
+    type: "no-payment-required";
+} | {
+    type: "payment-verified";
+    paymentPayload: PaymentPayload;
+    paymentRequirements: PaymentRequirements;
+} | {
+    type: "payment-error";
+    response: HTTPResponseInstructions;
+};
+/**
+ * Result of processSettlement
+ */
+type ProcessSettleSuccessResponse = SettleResponse & {
+    success: true;
+    headers: Record<string, string>;
+    requirements: PaymentRequirements;
+};
+type ProcessSettleFailureResponse = SettleResponse & {
+    success: false;
+    errorReason: string;
+};
+type ProcessSettleResultResponse = ProcessSettleSuccessResponse | ProcessSettleFailureResponse;
+/**
+ * Represents a validation error for a specific route's payment configuration.
+ */
+interface RouteValidationError {
+    /** The route pattern (e.g., "GET /api/weather") */
+    routePattern: string;
+    /** The payment scheme that failed validation */
+    scheme: string;
+    /** The network that failed validation */
+    network: Network;
+    /** The type of validation failure */
+    reason: "missing_scheme" | "missing_facilitator";
+    /** Human-readable error message */
+    message: string;
+}
+/**
+ * Error thrown when route configuration validation fails.
+ */
+declare class RouteConfigurationError extends Error {
+    /** The validation errors that caused this exception */
+    readonly errors: RouteValidationError[];
+    /**
+     * Creates a new RouteConfigurationError with the given validation errors.
+     *
+     * @param errors - The validation errors that caused this exception.
+     */
+    constructor(errors: RouteValidationError[]);
+}
+/**
+ * HTTP-enhanced x402 resource server
+ * Provides framework-agnostic HTTP protocol handling
+ */
+declare class x402HTTPResourceServer {
+    private ResourceServer;
+    private compiledRoutes;
+    private routesConfig;
+    private paywallProvider?;
+    /**
+     * Creates a new x402HTTPResourceServer instance.
+     *
+     * @param ResourceServer - The core x402ResourceServer instance to use
+     * @param routes - Route configuration for payment-protected endpoints
+     */
+    constructor(ResourceServer: x402ResourceServer, routes: RoutesConfig);
+    /**
+     * Initialize the HTTP resource server.
+     *
+     * This method initializes the underlying resource server (fetching facilitator support)
+     * and then validates that all route payment configurations have corresponding
+     * registered schemes and facilitator support.
+     *
+     * @throws RouteConfigurationError if any route's payment options don't have
+     *         corresponding registered schemes or facilitator support
+     *
+     * @example
+     * ```typescript
+     * const httpServer = new x402HTTPResourceServer(server, routes);
+     * await httpServer.initialize();
+     * ```
+     */
+    initialize(): Promise<void>;
+    /**
+     * Register a custom paywall provider for generating HTML
+     *
+     * @param provider - PaywallProvider instance
+     * @returns This service instance for chaining
+     */
+    registerPaywallProvider(provider: PaywallProvider): this;
+    /**
+     * Process HTTP request and return response instructions
+     * This is the main entry point for framework middleware
+     *
+     * @param context - HTTP request context
+     * @param paywallConfig - Optional paywall configuration
+     * @returns Process result indicating next action for middleware
+     */
+    processHTTPRequest(context: HTTPRequestContext, paywallConfig?: PaywallConfig): Promise<HTTPProcessResult>;
+    /**
+     * Process settlement after successful response
+     *
+     * @param paymentPayload - The verified payment payload
+     * @param requirements - The matching payment requirements
+     * @returns ProcessSettleResultResponse - SettleResponse with headers if success or errorReason if failure
+     */
+    processSettlement(paymentPayload: PaymentPayload, requirements: PaymentRequirements): Promise<ProcessSettleResultResponse>;
+    /**
+     * Check if a request requires payment based on route configuration
+     *
+     * @param context - HTTP request context
+     * @returns True if the route requires payment, false otherwise
+     */
+    requiresPayment(context: HTTPRequestContext): boolean;
+    /**
+     * Normalizes a RouteConfig's accepts field into an array of PaymentOptions
+     * Handles both single PaymentOption and array formats
+     *
+     * @param routeConfig - Route configuration
+     * @returns Array of payment options
+     */
+    private normalizePaymentOptions;
+    /**
+     * Validates that all payment options in routes have corresponding registered schemes
+     * and facilitator support.
+     *
+     * @returns Array of validation errors (empty if all routes are valid)
+     */
+    private validateRouteConfiguration;
+    /**
+     * Get route configuration for a request
+     *
+     * @param path - Request path
+     * @param method - HTTP method
+     * @returns Route configuration or undefined if no match
+     */
+    private getRouteConfig;
+    /**
+     * Extract payment from HTTP headers (handles v1 and v2)
+     *
+     * @param adapter - HTTP adapter
+     * @returns Decoded payment payload or null
+     */
+    private extractPayment;
+    /**
+     * Check if request is from a web browser
+     *
+     * @param adapter - HTTP adapter
+     * @returns True if request appears to be from a browser
+     */
+    private isWebBrowser;
+    /**
+     * Create HTTP response instructions from payment required
+     *
+     * @param paymentRequired - Payment requirements
+     * @param isWebBrowser - Whether request is from browser
+     * @param paywallConfig - Paywall configuration
+     * @param customHtml - Custom HTML template
+     * @param unpaidResponse - Optional custom response (content type and body) for unpaid API requests
+     * @returns Response instructions
+     */
+    private createHTTPResponse;
+    /**
+     * Create HTTP payment required response (v1 puts in body, v2 puts in header)
+     *
+     * @param paymentRequired - Payment required object
+     * @returns Headers and body for the HTTP response
+     */
+    private createHTTPPaymentRequiredResponse;
+    /**
+     * Create settlement response headers
+     *
+     * @param settleResponse - Settlement response
+     * @param requirements - Payment requirements that were settled
+     * @returns Headers to add to response
+     */
+    private createSettlementHeaders;
+    /**
+     * Parse route pattern into verb and regex
+     *
+     * @param pattern - Route pattern like "GET /api/*" or "/api/[id]"
+     * @returns Parsed pattern with verb and regex
+     */
+    private parseRoutePattern;
+    /**
+     * Normalize path for matching
+     *
+     * @param path - Raw path from request
+     * @returns Normalized path
+     */
+    private normalizePath;
+    /**
+     * Generate paywall HTML for browser requests
+     *
+     * @param paymentRequired - Payment required response
+     * @param paywallConfig - Optional paywall configuration
+     * @param customHtml - Optional custom HTML template
+     * @returns HTML string
+     */
+    private generatePaywallHTML;
+    /**
+     * Extract display amount from payment requirements.
+     *
+     * @param paymentRequired - The payment required object
+     * @returns The display amount in decimal format
+     */
+    private getDisplayAmount;
+}
+
+export { type CompiledRoute as C, type DynamicPayTo as D, type FacilitatorClient as F, type HTTPAdapter as H, type PaywallConfig as P, type RouteConfig as R, type UnpaidResponseBody as U, type HTTPRequestContext as a, type HTTPResponseInstructions as b, type HTTPProcessResult as c, type PaywallProvider as d, type PaymentOption as e, type RoutesConfig as f, type DynamicPrice as g, type UnpaidResponseResult as h, type ProcessSettleResultResponse as i, type ProcessSettleSuccessResponse as j, type ProcessSettleFailureResponse as k, type RouteValidationError as l, RouteConfigurationError as m, HTTPFacilitatorClient as n, type FacilitatorConfig as o, x402ResourceServer as p, type ResourceConfig as q, type ResourceInfo as r, x402HTTPResourceServer as x };