import { type PaymentChain } from "./paymentChains.js";
import { AiFinPayError } from "./errors.js";
import { type V14SettlementCall } from "./settlementV14.js";
import type { SpendLedgerBinding, QuoteAdmission } from "./spendLedger.js";
import { type SolanaV14Rpc, type SolanaV14SettlementCall, type SolanaV14Prepared, type SolanaV14Plan } from "./settlementSolanaV14.js";
import type { SolanaNetwork } from "./generated/solanaV14Deployments.generated.js";
import type { SdkEnvironment } from "./deploymentResolver.js";
import { type AgentFramework } from "./agent.js";
export declare class Aifp1Error extends AiFinPayError {
}
/** /v1/quote refused, or answered something that is not a quote. */
export declare class Aifp1QuoteError extends Aifp1Error {
}
/** The quote cannot be settled by this SDK (no asset we can send). */
export declare class Aifp1SettlementUnsupportedError extends Aifp1Error {
}
/**
 * Money moved on-chain but /v1/pay did not issue a receipt.
 *
 * Carries the tx hash because that is the only thing standing between the
 * caller and a lost payment: the quote is still settleable through
 * `POST /v1/pay` by hand with the same Idempotency-Key, and without the hash
 * in the error there is nothing to retry with. `recovery` additionally preserves
 * the quote nonce and issuer domain needed to sign a fresh receipt claim.
 */
export declare class Aifp1PayError extends Aifp1Error {
    readonly txRef?: string | undefined;
    readonly quoteId?: string | undefined;
    readonly recovery?: Aifp1PaymentRecovery | undefined;
    constructor(msg: string, txRef?: string | undefined, quoteId?: string | undefined, recovery?: Aifp1PaymentRecovery | undefined);
}
/** Canonical failed original transaction reconciled to one fee-only debit. */
export declare class Aifp1FinalizedFailureError extends Aifp1PayError {
    readonly feeAmountUsd: number;
    readonly actualFeeLamports: bigint;
    readonly code = "AIFP1_FINALIZED_FAILURE";
    constructor(recovery: Aifp1SolanaPaymentRecovery, feeAmountUsd: number, actualFeeLamports: bigint);
}
/** Public settlement context; contains no private key or authorization signature. */
export interface Aifp1EvmPaymentRecovery {
    family?: "evm";
    apiBaseUrl: string;
    quote: Aifp1Quote;
    txRef: `0x${string}`;
    asset: string;
    /** Trusted payment chain saved before broadcast; omitted legacy journals mean Polygon. */
    chain?: Aifp1V14Chain;
    paymentIssuer?: string;
    /** Local budget identity; never an amount, cap or server-selected ledger path. */
    budgetReservationId?: string;
    /** Version2 binds the independent cross-family wallet identity. */
    budgetBindingVersion?: 2;
    serializedTransaction?: `0x${string}`;
}
export interface Aifp1SolanaPaymentRecovery extends Omit<Aifp1EvmPaymentRecovery, "family" | "chain" | "txRef" | "serializedTransaction"> {
    family: "solana";
    chain: "solana";
    txRef: string;
    solana: SolanaV14Prepared;
    /** Locally validated gross plus fresh fee/rent cost; never recovery authority. */
    reservedAmountUsd: number;
    admissionSolUsdPrice: string;
    maxFeeLamports: string;
    transactionFeeLamports: string;
}
export type Aifp1PaymentRecovery = Aifp1EvmPaymentRecovery | Aifp1SolanaPaymentRecovery;
export type Aifp1SettlementChain = Aifp1V14Chain | "solana";
export interface Aifp1PaymentSigner {
    /** Independent local identity shared by all rails; never copied from a journal. */
    walletIdentity?: string;
    payerAddress: string;
    signPaymentAuthorization(message: string): Promise<string>;
    fetchImpl?: typeof fetch;
    /** Sent as AIFP-Agent-Framework on /v1/pay; unset sends no header. */
    framework?: AgentFramework;
    assertReservation?(id: string, txRef: string, binding: SpendLedgerBinding): Promise<void>;
    completeReservation?(id: string, txRef: string, binding: SpendLedgerBinding): Promise<void>;
    finalizeFailedReservation?(id: string, txRef: string, binding: SpendLedgerBinding, feeUsd: number): Promise<void>;
    solanaRpc?: SolanaV14Rpc;
}
export type Aifp1RecoveryOptions = Pick<Aifp1FetchOptions, "settlementConfirmMs" | "apiTimeoutMs" | "paymentIssuer" | "framework"> & {
    solanaNetwork?: SolanaNetwork;
    solanaEnvironment?: SdkEnvironment;
};
/** Exact owner/quote binding for a locally selected capped v1.4 payment. */
export declare function paymentBudgetBinding(payment: Pick<Aifp1PaymentRecovery, "apiBaseUrl" | "paymentIssuer" | "quote" | "chain" | "asset"> & {
    admissionSolUsdPrice?: string;
    maxFeeLamports?: string;
    transactionFeeLamports?: string;
}, payer: string, walletIdentity?: string): SpendLedgerBinding;
/** Recover an already settled payment. Never sends an on-chain transaction. */
export declare function recoverAifp1Payment(recovery: Aifp1PaymentRecovery, signer: Aifp1PaymentSigner, options?: Aifp1RecoveryOptions): Promise<Aifp1PayResult>;
/** The gateway rejected a receipt we believed covered the request. */
export declare class Aifp1ReceiptRejectedError extends Aifp1Error {
}
/**
 * A gateway site answered as a different merchant than the one it may be paid
 * as: the merchant this agent first paid there, or the caller's
 * `expectedMerchantId`. Nothing was quoted or paid.
 */
export declare class Aifp1MerchantChangedError extends Aifp1Error {
    readonly site: string;
    readonly expectedMerchantId: string;
    readonly merchantId: string;
    readonly code = "AIFP1_MERCHANT_CHANGED";
    constructor(site: string, expectedMerchantId: string, merchantId: string);
}
/**
 * 410 gateway_retired: the site that published this slug no longer serves it,
 * and the gateway never hands it to another site. Terminal — retrying or
 * buying a batch cannot succeed. Nothing was quoted or paid.
 */
export declare class Aifp1GatewayRetiredError extends Aifp1Error {
    readonly site: string;
    readonly code = "AIFP1_GATEWAY_RETIRED";
    constructor(site: string);
}
export type Aifp1Scope = "exact" | "prefix" | "merchant";
/** The 402 body — routes/gateway.js payChallenge(). */
export interface Aifp1Challenge {
    error: string;
    protocol: string;
    detail?: string;
    merchant_id: string;
    resource: string;
    unit_weight: number;
    base_unit_price_usd?: string;
    how_to_pay?: string[];
    scopes?: {
        note?: string;
        examples?: string[];
    };
}
/** POST /v1/quote 200 body — routes/aifp.js (`used` is stripped server-side). */
export interface Aifp1Quote {
    quote_id: string;
    payer?: string;
    network_mode?: "live" | "test";
    payment_authorization?: {
        scheme: "wallet-signature-v1";
        domain: string;
        max_age_seconds: number;
    };
    merchant_id: string;
    resource: string;
    scope: Aifp1Scope;
    tier: string;
    unit_price: string;
    requests: number;
    units: number;
    unit_quota: number;
    amount: string;
    currency: string;
    accepted_assets: string[];
    accepted_chains: string[];
    pay_to: Record<string, string>;
    /** The target and calldata the receipt verifier expects for this quote. */
    settlement_call?: V14SettlementCall | SolanaV14SettlementCall | {
        chain: string;
        contract: string;
        splitter_version: string;
        asset: string;
        function: string;
        arg_encoding: string;
        value_wei: string;
        args: {
            payment_id: string;
            merchant: string;
            gross_amount: string;
            ip_creator: string;
            valid_until: number;
            order_id: string;
        };
    };
    /** Exact stablecoin minor units; required for18dp, optional for legacy6dp. */
    token_settlement?: {
        asset: string;
        token: string;
        decimals: number;
        total_units: string;
        merchant_units: string;
        protocol_fee_units: string;
        creator_units: string;
        settlement_semantics: "gross-inclusive";
    };
    /** Native gross settlement in the selected chain currency, when backend readiness permits. */
    native_settlement?: Aifp1EvmNativeSettlement | Aifp1SolanaNativeSettlement;
    settlement: {
        batch_units: string;
        total_units: string;
        gross_units: string;
        payer_total_units: string;
        merchant_units: string;
        protocol_fee_units: string;
        creator_units: string;
        /** Canonical form, or the backend's retained legacy breakdown (not an extra fee). */
        fee_on_top: false | {
            provider: string;
            treasury: string;
            creator: string;
        };
        settlement_semantics?: "gross-inclusive";
    };
    nonce: string;
    expires_at: string;
}
export interface Aifp1EvmNativeSettlement {
    asset: string;
    decimals: number;
    rate_usd: string;
    rate_fixed_at?: string;
    total_wei: string;
    gross_wei?: string;
    payer_total_wei?: string;
    merchant_wei: string;
    treasury_wei: string;
    creator_wei: string;
    valid_until?: number | string;
    settlement_semantics?: "gross-inclusive";
}
export interface Aifp1SolanaNativeSettlement {
    asset: "SOL";
    decimals: 9;
    rate_usd: string;
    rate_fixed_at?: string;
    total_lamports: string;
    merchant_lamports: string;
    treasury_lamports: string;
    creator_lamports: string;
    valid_until?: number | string;
    settlement_semantics: "gross-inclusive";
}
/**
 * A one-object, human-and-LLM-readable summary of what a quote actually buys.
 *
 * The raw quote answers "1.06 POL" and leaves the agent — or the person reading
 * over its shoulder — to work out FOR WHAT. That is the gap an agent-flow audit
 * flagged: a payment prompt that states an amount without the terms is a prompt
 * a careful agent should refuse, and a careless one over-pays on. Every field
 * here already exists in the quote; this just assembles them into the sentence
 * a reasonable payer needs before signing.
 */
export interface QuoteSummary {
    /** One line, safe to show a user or feed an LLM: what, how much, how many, until when. */
    headline: string;
    amount_usd: string;
    /** The on-chain figure and its asset, when the quote is settled natively. */
    pay: {
        amount: string;
        asset: string;
    } | null;
    /** How many requests this batch covers, and each request's weight. */
    requests: number;
    unit_quota: number;
    /** WHERE the batch may be spent — the single most misread field (see the
     *  wildcard bug): "exact" buys one path, "prefix" buys a subtree. */
    scope: Aifp1Scope;
    resource: string;
    /** When the quote stops being settleable. */
    expires_at: string;
    /** The protocol fee, stated up front. */
    fee_bps: number | null;
}
export declare function describeQuote(q: Aifp1Quote): QuoteSummary;
/** POST /v1/pay 200 body — routes/aifp.js. */
export interface Aifp1PayResult {
    network?: SolanaNetwork;
    program?: string;
    receipt_id: string;
    receipt: string;
    status: string;
    tx_ref: string;
    merchant_id: string;
    resource: string;
    scope: Aifp1Scope;
    amount: string;
    currency: string;
    quota: number;
    unit_quota: number;
    asset: string;
    chain: string;
    settled_at: string;
    expires_at: string;
    policy_exceeded?: boolean;
    policy_reason?: string;
}
/** Mirror of scope.js scopeCovers(). */
export declare function scopeCovers(scope: string | undefined, resource: string, path: string): boolean;
/**
 * Mirror of scope.js patternCovers(): a merchant registers "/movies/*" as ONE
 * resource, and both the 402 and the receipt name that pattern rather than the
 * URL. It covers "/movies" and everything under "/movies/".
 *
 * This port stopped at `path === resource` while the server and @aifinpay/gate
 * learnt wildcards, so a direct Raters page (402 for "/movies/*" on
 * "/movies/11/that-70s-show") was refused before quoting, and a receipt bought
 * for the pattern was never found in the cache for the next page.
 */
export declare function patternCovers(pattern: string, path: string): boolean;
/**
 * Mirror of routes/gateway.js prefixHint(): /articles/2026/thing → /articles/,
 * and a single-segment path → "/" (the whole site).
 */
export declare function prefixHint(path: string): string;
/**
 * Split a gateway URL the way routes/gateway.js splits it: first path segment
 * is the merchant slug, the rest is the merchant-relative resource, and the
 * query string is not part of either.
 *
 * `site` (origin + slug) is the cache key. It is the only merchant identity
 * available before the first 402 answers with a merchant_id. The gateway
 * repeats the slug → merchant lookup on every request and a slug can change
 * hands, so a site is pinned to the merchant it was first paid as (see Merchant
 * pins).
 */
/**
 * Gateway origins this client will settle against.
 *
 * Without this the client paid whoever answered. parseGatewayUrl looked only
 * at the path, so ANY host could return {error:"AIFP-402", protocol:"AIFP-1",
 * merchant_id:"mrch_theirs"} and the agent would quote, settle real POL to the
 * address in that quote, and hand over a receipt. The 402 is unauthenticated
 * by construction — it is the answer to a request that carried no credentials —
 * so the only thing separating a paywall from a trap is knowing whose paywall
 * it is.
 *
 * Override for self-hosted gateways; an empty list is refused rather than
 * treated as "allow all", because that is the shape a config bug takes.
 */
export declare const DEFAULT_GATEWAY_ORIGINS: readonly ["https://gateway.aifinpay.io"];
export declare function parseGatewayUrl(url: string, allowedOrigins?: readonly string[], resourcePathMode?: "gateway" | "direct"): {
    site: string;
    slug: string;
    restPath: string;
};
/**
 * The `exp` of a receipt JWT, in ms, without verifying it — we are not
 * authenticating the token here, only recovering a expiry the response failed
 * to state. Returns null if the claim is absent or unreadable.
 */
export declare function jwtExpiryMs(jwt: string): number | null;
/**
 * The Idempotency-Key for one /v1/pay call. Required by the server
 * (routes/aifp.js: 400 without it) and load-bearing here for a different
 * reason: it is what stops one settled transaction being turned into two
 * receipts, or a network blip during /v1/pay from becoming a second on-chain
 * payment on retry.
 *
 * Derived from exactly the four fields the server itself hashes into its
 * idempotency record — quote_id, asset, chain, tx_ref. That equivalence is the
 * point:
 *
 *   • the same payment retried ⇒ the same key ⇒ the server replays the first
 *     response instead of issuing a second receipt;
 *   • a different payment ⇒ a different key, because a different payment must
 *     differ in at least one of those four (quote_id alone is single-use —
 *     `quote.used` makes a second settlement of one quote a 409);
 *   • and the server's "same key, different body → 409" branch is unreachable
 *     from this client, since the key is a pure function of that body.
 *
 * A random key would satisfy the header requirement and none of the above.
 */
export declare function idempotencyKeyFor(p: {
    quoteId: string;
    chain: string;
    asset: string;
    txRef: string;
}): string;
export interface Aifp1CachedReceipt {
    /** origin + slug, as parseGatewayUrl() computes it. */
    site: string;
    merchantId: string;
    receiptId: string;
    /** The bearer JWT. Never log this. */
    jwt: string;
    scope: Aifp1Scope;
    resource: string;
    unitQuota: number;
    /** Billing units we believe are left. Corrected from AIFP-Quota-Remaining. */
    remaining: number;
    /** JWT expiry, ms epoch. */
    expiresAt: number;
    amountUsd: number;
}
/** Where the merchant each gateway site was first paid as is remembered. */
export interface Aifp1MerchantPinStore {
    /** The merchant `site` is pinned to, or undefined if it never was. */
    get(site: string): Promise<string | undefined>;
    /** Pin `site` to `merchantId`, replacing any earlier pin. Durable once it resolves. */
    set(site: string, merchantId: string): Promise<void>;
}
/** Pins that last as long as the process. */
export declare class MemoryMerchantPinStore implements Aifp1MerchantPinStore {
    private readonly pins;
    get(site: string): Promise<string | undefined>;
    set(site: string, merchantId: string): Promise<void>;
}
/**
 * One owner-only JSON file per site under `directory`, named by the SHA-256 of
 * the site. A file per site makes every pin one atomic rename: no lock, and
 * two processes pinning different sites cannot lose each other's write.
 */
export declare class FileMerchantPinStore implements Aifp1MerchantPinStore {
    readonly directory: string;
    constructor(directory: string);
    /** `merchant-pins` beside the spend ledger: AIFINPAY_STATE_DIR, or ~/.aifinpay. */
    static default(): FileMerchantPinStore;
    private path;
    get(site: string): Promise<string | undefined>;
    set(site: string, merchantId: string): Promise<void>;
}
/**
 * The receipts this agent holds, and the rules for spending them.
 *
 * In-memory and per-agent-instance: a receipt is a bearer credential, and
 * writing one to disk by default would be a bigger decision than a cache
 * deserves. An agent that wants batches to survive a restart can hold the
 * entries itself (they are plain data) and re-seed a cache.
 *
 * `merchantPins` is not a credential, and a pin a restart forgets protects
 * nothing, so AiFinPayAgent backs it with files; a bare cache keeps it in memory.
 */
export declare class Aifp1ReceiptCache {
    readonly merchantPins: Aifp1MerchantPinStore;
    private readonly entries;
    constructor(merchantPins?: Aifp1MerchantPinStore);
    /**
     * Batch purchases in flight, keyed by site.
     *
     * The cache is empty between deciding to buy and the receipt arriving, so
     * ten workers sharing one agent all missed, all got a 402, and all settled
     * their own batch — ten on-chain payments and ten minimum charges where one
     * would have covered every worker. It recurred at each quota boundary, so
     * the more traffic an agent had the more it overpaid.
     *
     * Second and later callers await the first purchase, then re-check the
     * cache: whoever wins buys a batch wide enough that the rest find it
     * covering their path too. If it does not cover them (a different prefix)
     * they fall through and buy their own, which is correct — that is a
     * different batch, not a duplicate.
     */
    private readonly inflight;
    /** Run `buy` for `site`, or await the purchase already running for it. */
    coalesce<T>(site: string, buy: () => Promise<T>): Promise<T | "retry">;
    /**
     * The receipt to send for this request, if we hold one.
     *
     * Three conditions, all necessary:
     *   • same merchant — a receipt's `aud` is the merchant id, so sending one
     *     elsewhere is at best a 403 and at worst paying the wrong party;
     *   • the scope covers the path — the same test the gateway will apply;
     *   • quota left and not expired.
     *
     * `remaining > 0` rather than `remaining >= weight`: we only learn a route's
     * weight from a 402 refusing it, so the weight of a path we have not been
     * refused on is genuinely unknown here. The gateway's meter is authoritative
     * and answers 402 "quota exhausted" when the batch cannot cover the call —
     * at which point we re-quote. Guessing a weight would only add a way to be
     * wrong in the direction of not spending a batch we own.
     */
    find(site: string, restPath: string, merchantId?: string): Aifp1CachedReceipt | undefined;
    put(entry: Aifp1CachedReceipt): void;
    /** The gateway's own count wins over ours — it is the one doing the metering. */
    noteQuotaRemaining(entry: Aifp1CachedReceipt, remaining: number): void;
    evict(entry: Aifp1CachedReceipt): void;
    /** Everything we still hold, expired entries dropped. Plain data, copyable. */
    list(): Aifp1CachedReceipt[];
    /**
     * Redacted view for dashboards and MCP tools: everything except the bearer
     * `jwt` (a credential — only the paying agent holds it). Safe to log.
     */
    summary(): Omit<Aifp1CachedReceipt, "jwt">[];
    get size(): number;
}
export type Aifp1V14Chain = PaymentChain;
export interface Aifp1FetchOptions {
    /** Explicit reporting.v2 capability. Sent only to canonical first-party
     * /v1/quote, in memory; never pay/auth/access/journal/recovery authority. */
    reportingToken?: string;
    /** Solana is explicitly owner-authorized; cannot coexist with EVM v14.
     * maxFeeLamports includes transaction fees AND nonce/ATA account rent. */
    solanaV14?: {
        environment: SdkEnvironment;
        network: SolanaNetwork;
        asset?: string;
        maxFeeLamports: bigint;
        onPrepared: (payment: Aifp1SolanaPaymentRecovery) => Promise<void>;
    };
    /** Explicit native v1.4 authorization. Deployment/signer pins come from the
     * SDK registry, never from a merchant response. The journal must be durable
     * before broadcast; a prepared transaction must be recovered, never replaced. */
    v14?: {
        /** Independently selected payment chain. Defaults to Polygon; never inferred from a quote. */
        chain?: Aifp1V14Chain;
        /**
         * Native currency (POL/ETH), or a stablecoin pinned for the selected chain.
         * Defaults to native. Stablecoins need no nativeUsdPrice; maxGasWei covers
         * approval and settlement. On Base it includes buffered L1/operator fee
         * estimates, which can change before inclusion and are not a consensus cap.
         */
        asset?: string;
        maxGasWei: bigint;
        onPrepared: (payment: Aifp1PaymentRecovery & {
            serializedTransaction: `0x${string}`;
        }) => Promise<void>;
    };
    /** Reviewed v1.3 deployment pin, supplied independently of the quote server.
     * The receipt flow currently verifies Polygon native settlements only. */
    settlementPin?: import("./settlement.js").TrustedSettlementRoutePin;
    /** Independent native/USD observation from the caller's trusted price source,
     * never copied from the payment quote. POL/USD on Polygon, ETH/USD on Base.
     * Required for native v1.3/v1.4 payments; <=60s old. */
    nativeUsdPrice?: {
        usd: number;
        observedAtMs: number;
    } | (() => Promise<{
        usd: number;
        observedAtMs: number;
    }>);
    /**
     * How wide a batch to buy. Default "prefix" — see the comment on
     * resolveScope() for why the default is not "exact".
     */
    scope?: Aifp1Scope;
    /** Override the resource the batch is scoped to (ignored for "merchant"). */
    resource?: string;
    /**
     * Billing units to prepay. Omit it and the client buys roughly
     * DEFAULT_BATCH_USD worth, computed from the base unit price the gateway
     * states in its own 402 — so the batch stays the same amount of MONEY when
     * the tiers move.
     */
    units?: number;
    /** Maximum quoted batch cost in USD; only tightens the agent's budget caps. */
    maxAmountUsd?: number;
    /** Where /v1/quote and /v1/pay live. Default https://api.aifinpay.io */
    apiBaseUrl?: string;
    /** Per-API request deadline, including the body. Default 15 seconds. */
    apiTimeoutMs?: number;
    /** Independently configured receipt issuer. Defaults to https://api.aifinpay.io. */
    paymentIssuer?: string;
    /**
     * Gateway origins this client will settle against. Defaults to
     * DEFAULT_GATEWAY_ORIGINS — set it only for a self-hosted gateway, and
     * never to a host you do not control the paywall of.
     */
    gatewayOrigins?: readonly string[];
    /**
     * "gateway" strips the hosted merchant slug (default). "direct" uses the
     * full URL pathname and probes for the merchant before reusing a receipt.
     * Direct origins must still be explicitly trusted through gatewayOrigins.
     */
    resourcePathMode?: "gateway" | "direct";
    /**
     * The merchant_id this call may pay. A 402 naming any other is refused
     * before quoting, whatever the site's pin says; paying re-pins the site.
     */
    expectedMerchantId?: string;
    /**
     * Pay a gateway site's current merchant although the site was first paid as
     * another one; paying re-pins the site. Off by default, because the 402 that
     * names the merchant is unauthenticated.
     */
    allowMerchantChange?: boolean;
    /** Value for the AIFP-Agent-Id header; defaults to the agent's EVM address. */
    agentId?: string;
    /**
     * AIFP-Agent-Framework for this call, replacing the agent's `framework`
     * option — for a host that learns its AI client after constructing the agent.
     * Read by AiFinPayAgent.fetchPaid/recoverPaidPayment; the low-level
     * aifp1Fetch/recoverAifp1Payment send `deps.framework`/`signer.framework`.
     */
    framework?: AgentFramework;
    /** How long to keep retrying /v1/pay while the chain catches up (AIFP-425). */
    settlementConfirmMs?: number;
}
/** Units to buy so the batch is worth about DEFAULT_BATCH_USD. */
export declare function defaultUnitsFor(challenge: Pick<Aifp1Challenge, "base_unit_price_usd">): number;
/**
 * Everything the flow needs that is not the AIFP-1 protocol itself. The
 * settlement and the budget hooks are AiFinPayAgent's; splitting them out is
 * what lets the protocol be tested without a chain.
 */
export interface Aifp1Deps {
    walletIdentity?: string;
    /** Independently configured RPC/owner limits, never recovered from the journal. */
    quoteOwnerContext?: string;
    beginQuoteAdmission?(binding: SpendLedgerBinding, context: string, create: () => Promise<{
        requestBody: string;
        statement: string;
    }>): Promise<QuoteAdmission>;
    adoptQuoteAdmission?(id: string, binding: SpendLedgerBinding, context: string, quoteJson: string): Promise<void>;
    closeQuoteAdmission?(id: string, binding: SpendLedgerBinding, context: string, terminal: "not-admitted" | "expired-unbroadcast", quoteJson?: string): Promise<void>;
    verifyHistoricalSolanaQuote?(call: SolanaV14SettlementCall, auth: NonNullable<Aifp1FetchOptions["solanaV14"]>, orderId: string): Promise<void>;
    prepareSolana?(call: SolanaV14SettlementCall, authorization: NonNullable<Aifp1FetchOptions["solanaV14"]>, orderId: string): Promise<SolanaV14Plan>;
    settleSolana?(plan: SolanaV14Plan, onPrepared: (tx: SolanaV14Prepared) => Promise<void>): Promise<SolanaV14Prepared>;
    fetchImpl: typeof fetch;
    cache: Aifp1ReceiptCache;
    /** AIFP-Agent-Id / agent_id — a 0x address, or agent policies cannot key on it. */
    agentId: string;
    /** AIFP-Agent-Framework on every request of the flow; unset sends no header. */
    framework?: AgentFramework;
    /** Actual settlement wallet, independent of any display/agent identifier. */
    payerAddress: string;
    signPaymentAuthorization(message: string): Promise<string>;
    /**
     * Settle one canonical v1.3 gross amount, returning a hash whose transaction
     * was included AND succeeded. Implementations must independently verify the
     * deployment/runtime profile before signing.
     */
    settle(p: {
        merchantWallet: `0x${string}`;
        grossWei: bigint;
        merchantWei: bigint;
        treasuryWei: bigint;
        creatorWei: bigint;
        validUntil: bigint;
        orderId: string;
        settlementCall?: Aifp1Quote["settlement_call"];
        /** The token a stablecoin purchase was authorized in; omitted = native. */
        token?: `0x${string}`;
        onPrepared?: (tx: {
            hash: `0x${string}`;
            serializedTransaction: `0x${string}`;
        }) => Promise<void>;
    }): Promise<`0x${string}`>;
    /** Per-call cap. false ⇒ the caller asked to skip rather than throw. */
    checkPerCall(usd: number): boolean;
    /** Daily cap. "skip" ⇒ drop the call; a string is a reservation to resolve. */
    reserveDaily(usd: number, binding?: SpendLedgerBinding, admissionId?: string): Promise<string | null | "skip">;
    commit(reservationId: string, usd: number): Promise<void>;
    release(reservationId: string): Promise<void>;
    prepareReservation?(id: string, txRef: string, binding: SpendLedgerBinding): Promise<void>;
    assertReservation?(id: string, txRef: string, binding: SpendLedgerBinding): Promise<void>;
    completeReservation?(id: string, txRef: string, binding: SpendLedgerBinding): Promise<void>;
    finalizeFailedReservation?(id: string, txRef: string, binding: SpendLedgerBinding, feeUsd: number): Promise<void>;
    onPaid?(info: {
        merchantId: string;
        amountUsd: number;
        txRef: string;
        receiptId: string;
    }): void;
}
/**
 * Fetch a gateway URL, paying the AIFP-1 paywall if it asks.
 *
 * Returns the merchant's response. Returns null only when a budget cap was hit
 * and `on_limit_exceeded` is "skip" — the same contract AiFinPayAgent.call()
 * already has.
 */
export declare function aifp1Fetch(deps: Aifp1Deps, url: string, init?: RequestInit, opts?: Aifp1FetchOptions): Promise<Response | null>;
/** Sign only this locally constructed request; a server cannot choose the
 * ownership statement. Retry the same body/nonce after an uncertain response. */
export declare function solanaQuoteAuthorizationMessage(body: Record<string, unknown>, auth: {
    network: SolanaNetwork;
    network_mode: "live" | "test";
    payer: string;
    nonce: string;
    expires_at: number;
}, issuer: string): string;
/** Fixed, domain-separated receipt claim; sign with the wallet that settled. */
export declare function paymentAuthorizationMessage(p: {
    quote: Aifp1Quote;
    apiBase: string;
    chain: string;
    txRef: string;
    asset: string;
    idempotencyKey: string;
    payer: string;
    expiresAt: number;
    issuer?: string;
}): string;
//# sourceMappingURL=aifp1.d.ts.map