export { B as BridgePluginConfig, D as DynamicPrice, j as FeedbackPluginConfig, F as FreeTierPluginConfig, M as MppServerHandler, b as PaymentInfo, g as PluginContext, h as PluginResult, P as ProtectOptions, R as Relai, d as RelaiIntegritasFlow, e as RelaiIntegritasOptions, f as RelaiPlugin, a as RelaiServerConfig, i as ScorePluginConfig, S as SettleResult, k as SolanaFeedbackPluginConfig, c as StripePayTo, R as default, s as stripePayTo } from './server-DgMG2zhy.cjs';
export { MppHandler, RelayWebSocketFactory, RelayWebSocketLike, X402Client, X402ClientConfig, X402FetchInit, X402IntegritasConfig, X402IntegritasFlow, X402NetworkSelectionMode, X402RelayWsConfig, X402RelayWsError, X402RelayWsResponse, X402RequestOptions, default as createX402Client } from './client.cjs';
export { RelayFeedbackConfig, submitRelayFeedback } from './relay-feedback.cjs';
export { A as AcceptsExtra, B as BASE_MAINNET_NETWORK, C as CAIP2_TO_NETWORK, b as CHAIN_IDS, E as EXPLORER_TX_URL, l as EvmWallet, N as NETWORK_CAIP2, e as NETWORK_LABELS, d as NETWORK_TOKENS, c as NetworkToken, P as PaymentAccept, o as PaymentRequired, a as RELAI_FACILITATOR_URL, i as RELAI_NETWORKS, R as RelaiNetwork, m as ResourceInfo, f as SOLANA_MAINNET_NETWORK, S as SolanaWallet, U as USDC_ADDRESSES, h as USDC_BASE, g as USDC_SOLANA, W as WalletSet, k as isEvm, j as isSolana, n as normalizeNetwork, r as resolveToken } from './types-DjEveKgt.cjs';
export { BridgeBalances, BridgeQuoteResult, BridgeResult } from './management.cjs';
export { NETWORK_V1_TO_V2, NETWORK_V2_TO_V1, convertPayloadToVersion, convertV1ToV2, convertV2ToV1, detectPayloadVersion, formatUsd, fromAtomicUnits, isEvmNetwork, isSolanaNetwork, networkV1ToV2, networkV2ToV1, normalizePaymentHeader, toAtomicUnits } from './utils/index.cjs';
export { charge as evmChargeMethod } from './mpp/evm-method.cjs';
export { EvmChargeConfig, evmCharge as evmChargeServer } from './mpp/evm-server.cjs';
export { EvmChargeClientConfig, evmCharge as evmChargeClient } from './mpp/evm-client.cjs';
import 'mppx';
import 'zod/v4/core';
import 'zod/mini';
import 'viem';

/**
 * Payment Code API — BLIK-style x402 payment codes
 *
 * createPrivateKeySigner()    — create a signer from a raw private key (for agents/bots)
 * generatePaymentCode()       — sign EIP-3009 authorization and register on SKALE L3
 * generatePaymentCodesBatch() — register up to 20 codes in one call (agent budget)
 * redeemPaymentCode()         — redeem a code (payee calls this, triggers Base L2 settlement)
 * getPaymentCode()            — check code status
 * cancelPaymentCode()         — cancel/revoke a code before redemption
 */
type PaymentCodeNetwork = "base" | "base-sepolia" | "skale-base" | "skale-base-sepolia";
interface NetworkConfig {
    chainId: number;
    usdc: string;
    /** EIP-712 domain name of the USDC contract on this network */
    domainName: string;
    rpc: string;
    settlementNetwork: string;
}
declare const NETWORK_CONFIGS: Record<PaymentCodeNetwork, NetworkConfig>;
interface PaymentCodeSigner {
    getAddress(): Promise<string>;
    signTypedData(domain: object, types: object, value: object): Promise<string>;
}
/**
 * Create an EIP-712 signer from a raw private key.
 * Intended for agents/bots running server-side with a custodial wallet.
 *
 * @example
 * const signer = createPrivateKeySigner(process.env.AGENT_PRIVATE_KEY!);
 * const { code } = await generatePaymentCode(config, { signer, value: 1_000_000n });
 */
declare function createPrivateKeySigner(privateKey: string): PaymentCodeSigner;
interface PaymentCodeConfig {
    /** RelAI facilitator base URL (default: https://relai.fi/facilitator) */
    facilitatorUrl?: string;
}
interface GeneratePaymentCodeParams {
    /** EIP-3009 signer — use createPrivateKeySigner() for agents */
    signer: PaymentCodeSigner;
    /** Settlement network (default: "base-sepolia") */
    network?: PaymentCodeNetwork;
    /** Amount in USDC micro-units (6 decimals), e.g. 1_000_000 = $1.00 */
    value: string | bigint;
    /** TTL in seconds (default: 86400 = 24 h) */
    ttl?: number;
    /** Optional message shown to the recipient when they claim */
    description?: string;
    /**
     * Lock the code to a specific payee address — only that address can redeem it.
     * Useful for agent-to-agent payments or scheduled disbursements.
     */
    payee?: string;
    /** Override the USDC contract address */
    usdcContract?: string;
}
interface BatchCodeItem {
    /** Amount in USDC micro-units */
    value: string | bigint;
    /** TTL in seconds (default: 86400) */
    ttl?: number;
}
interface GeneratePaymentCodesBatchParams {
    signer: PaymentCodeSigner;
    /** Settlement network (default: "base-sepolia") */
    network?: PaymentCodeNetwork;
    /** Up to 20 codes to register */
    codes: BatchCodeItem[];
    /** Lock all codes to a specific payee */
    payee?: string;
    /** Override the USDC contract address */
    usdcContract?: string;
    /** RelAI auth token (required — batch endpoint is authenticated) */
    authToken?: string;
}
interface PaymentCode {
    code: string;
    validBefore: number;
    expiresIn: number;
    relayerAddress: string;
    settlementNetwork: string;
    locked: boolean;
    description?: string | null;
}
interface BatchPaymentCodesResult {
    registered: number;
    codes: Pick<PaymentCode, "code" | "validBefore" | "expiresIn" | "locked">[];
    failed: {
        index: number;
        error: string;
    }[];
    relayerAddress: string;
    settlementNetwork: string;
}
interface RedeemResult {
    success: boolean;
    code: string;
    l3TxHash: string;
    l2TxHash: string;
    explorerUrl: string;
    settlementNetwork: string;
    private: boolean;
    amount: string;
    from: string;
    payee: string;
    /** Amount returned as change (µUSDC), present when invoiceAmount < code value */
    change?: string;
    /** How the change was returned: 'code' = new payment code, 'wallet' = sent to from address */
    changeMode?: 'code' | 'wallet';
    /** New payment code for the change amount (present when changeMode === 'code') */
    changeCode?: string;
}
interface CodeStatus {
    code: string;
    from: string;
    to: string;
    value: string;
    validBefore: number;
    redeemed: boolean;
    expired: boolean;
    redeemable: boolean;
    settlementNetwork: string | null;
    description: string | null;
}
/**
 * Generate a BLIK-style x402 payment code backed by an EIP-3009 authorization.
 * The facilitator registers it on SKALE L3 — no gas cost for the payer.
 * The `to` address (settler/relayer) is fetched automatically from the facilitator.
 *
 * @example Agent usage (Node.js / server-side):
 * ```ts
 * import { createPrivateKeySigner, generatePaymentCode } from '@relai-fi/x402';
 *
 * const signer = createPrivateKeySigner(process.env.AGENT_PRIVATE_KEY!);
 * const { code } = await generatePaymentCode(
 *   { facilitatorUrl: 'https://relai.fi/facilitator' },
 *   { signer, value: 1_000_000n, ttl: 3600, description: 'coffee' },
 * );
 * // code = "X7K9P2AB" — share with the payee, e.g. via SMS / email / QR
 * ```
 */
declare function generatePaymentCode(config: PaymentCodeConfig, params: GeneratePaymentCodeParams): Promise<PaymentCode>;
/**
 * Generate multiple payment codes in one call — agent budget allocation pattern.
 * Each code is independently signed. Max 20 codes per call.
 * Requires a valid RelAI `authToken`.
 *
 * @example
 * ```ts
 * const { codes } = await generatePaymentCodesBatch(config, {
 *   signer,
 *   authToken: process.env.RELAI_API_KEY!,
 *   codes: Array(10).fill({ value: 1_000_000n, ttl: 3600 }),  // 10 × $1.00
 * });
 * // codes[0].code = "X7K9P2AB", codes[1].code = "B3R5N7QA", …
 * ```
 */
declare function generatePaymentCodesBatch(config: PaymentCodeConfig, params: GeneratePaymentCodesBatchParams): Promise<BatchPaymentCodesResult>;
/**
 * Redeem a payment code. Triggers USDC settlement on Base L2 or SKALE.
 * No wallet connection needed on the payee side — just provide a destination address.
 *
 * @example
 * ```ts
 * const result = await redeemPaymentCode(config, "X7K9P2AB", "0xYourWallet...");
 * console.log(result.explorerUrl); // https://sepolia.basescan.org/tx/0x...
 * ```
 */
declare function redeemPaymentCode(config: PaymentCodeConfig, code: string, 
/** Address to receive the USDC (required unless code was registered with a locked payee) */
payee?: string): Promise<RedeemResult>;
/**
 * Get the current status of a payment code.
 */
declare function getPaymentCode$1(config: PaymentCodeConfig, code: string): Promise<CodeStatus>;
/**
 * Cancel a payment code before it is redeemed.
 * Soft-cancels immediately (relayer will refuse to settle);
 * also attempts a hard-cancel on SKALE L3 to mark it used on-chain.
 */
declare function cancelPaymentCode(config: PaymentCodeConfig, code: string): Promise<{
    success: boolean;
    l3TxHash: string | null;
}>;

/**
 * Payment Request API — Merchant-initiated x402 payment codes
 *
 * Flow (reverse of payment-codes):
 *   1. Merchant calls createPayRequest() → gets a short code
 *   2. Merchant shares the code with the buyer (QR, link, message)
 *   3. Buyer calls getPayRequest() → sees amount, merchant, description
 *   4. Buyer calls payPayRequest() with their signer → USDC sent directly to merchant
 *
 * createPayRequest()  — merchant creates a payment request (no signature needed)
 * getPayRequest()     — buyer reads request details (amount, merchant, description)
 * payPayRequest()     — buyer signs EIP-3009 and submits payment
 */

/**
 * Networks supported for payment requests.
 * Extends EVM payment code networks with Solana mainnet/devnet.
 */
type PaymentRequestNetwork = PaymentCodeNetwork | "solana" | "solana-devnet";
interface PaymentRequestConfig {
    /** RelAI facilitator base URL (default: https://relai.fi/facilitator) */
    facilitatorUrl?: string;
}
interface CreatePayRequestParams {
    /** Merchant wallet address — EVM (0x...) for EVM networks, base58 for Solana */
    to: string;
    /** Amount in USDC micro-units (6 decimals), e.g. 1_000_000 = $1.00 */
    amount: number | bigint;
    /**
     * Settlement network — where the merchant receives USDC.
     * Default: "base-sepolia".
     * Solana options: "solana-devnet" | "solana"
     */
    network?: PaymentRequestNetwork;
    /** Payment description shown to the buyer, e.g. "Coffee ☕" */
    description?: string;
    /** Code TTL in seconds (min 60, max 86400, default 3600) */
    ttlSeconds?: number;
}
interface PayRequest {
    /** 8-character alphanumeric code, e.g. "X7K9P2AB" */
    code: string;
    /** Unix timestamp when the request expires */
    validUntil: number;
    /** Address the buyer must use as EIP-3009 `to` (settler/relayer, NOT merchant directly) */
    toAddress: string;
    /** USDC contract on the settlement network */
    usdcContract: string;
}
interface PayRequestInfo {
    code: string;
    /** Merchant wallet address */
    to: string;
    /** EIP-3009 `to` address (settler/relayer) */
    toAddress: string;
    amount: number;
    network: string;
    usdcContract: string;
    description: string | null;
    validUntil: number;
    expiresIn: number;
    status: "pending" | "processing" | "paid";
    payable: boolean;
}
interface PayRequestResult {
    success: boolean;
    code: string;
    payTxHash: string | null;
    explorerUrl?: string;
    network?: string;
    private?: boolean;
    amount?: string;
    /** Merchant address that received the USDC */
    to?: string;
}
/**
 * Create a payment request — merchant/seller side.
 * No signing required. Returns a short code to share with the buyer.
 *
 * @example Merchant/agent creates a $5 invoice:
 * ```ts
 * const req = await createPayRequest(config, {
 *   to:          '0xMerchantWallet...',
 *   amount:      5_000_000,   // $5.00 USDC
 *   network:     'base-sepolia',
 *   description: 'Order #1234 — 2× coffee',
 *   ttlSeconds:  900,         // 15 minutes
 * });
 * // req.code = "X7K9P2AB" — share via QR / link / message
 * // link: https://relai.fi/pay#X7K9P2AB
 * ```
 */
declare function createPayRequest(config: PaymentRequestConfig, params: CreatePayRequestParams): Promise<PayRequest>;
/**
 * Get the status and details of a payment request — buyer side.
 *
 * @example
 * ```ts
 * const info = await getPayRequest(config, 'X7K9P2AB');
 * console.log(`Pay $${info.amount / 1e6} to ${info.to}`);
 * console.log('Description:', info.description);
 * console.log('Payable:', info.payable);
 * ```
 */
declare function getPayRequest(config: PaymentRequestConfig, code: string): Promise<PayRequestInfo>;
/**
 * Pay a payment request — buyer side.
 * Signs an EIP-3009 authorization and submits it to the facilitator,
 * which executes the on-chain transfer to the merchant.
 *
 * @example Buyer pays using a private key (agent):
 * ```ts
 * import { createPrivateKeySigner } from '@relai-fi/x402';
 *
 * const signer = createPrivateKeySigner(process.env.BUYER_PRIVATE_KEY!);
 * const result = await payPayRequest(config, 'X7K9P2AB', signer);
 * console.log('Paid! Explorer:', result.explorerUrl);
 * ```
 */
declare function payPayRequest(config: PaymentRequestConfig, code: string, signer: PaymentCodeSigner): Promise<PayRequestResult>;
/**
 * Pay a merchant's payment request using a pre-generated payment code.
 * The buyer already holds a BLIK-style code (created via generatePaymentCode) —
 * instead of signing on the spot, they redeem that code and USDC goes to the merchant.
 *
 * The payment code must have enough value to cover the request amount.
 * If the code was created without a locked payee, the merchant address is set at redemption time.
 *
 * @example
 * ```ts
 * // Merchant shares their invoice code: "SHOP1234"
 * // Buyer has a pre-generated payment code: "MYBLIK78"
 * const result = await payPayRequestWithCode(config, 'SHOP1234', 'MYBLIK78');
 * console.log('Paid! Explorer:', result.explorerUrl);
 * ```
 */
interface SolanaWalletAdapter$1 {
    /** Solana wallet public key */
    publicKey: {
        toString(): string;
    } | null;
    /** Signs a Solana transaction (buyer's signature) */
    signTransaction<T>(transaction: T): Promise<T>;
}
interface SolanaPayRequestOptions {
    /** Override Solana network (default: auto-detected from relayer-info) */
    solanaNetwork?: 'solana' | 'solana-devnet';
    /** Solana RPC URL (default: public mainnet/devnet) */
    solanaRpcUrl?: string;
}
interface SolanaPayRequestResult {
    success: boolean;
    code: string;
    /** EVM tx hash — merchant received USDC on Base/SKALE */
    payTxHash: string;
    /** EVM explorer link */
    explorerUrl: string;
    /** Solana tx hash — buyer paid USDC from their Solana wallet */
    solanaTxHash: string;
    /** Solana explorer link */
    solanaExplorerUrl: string;
    amount: string;
    /** Merchant EVM address */
    to: string;
    /** Merchant settlement network */
    network: string;
}
interface PayPayRequestWithCodeOptions {
    /**
     * How to return the change when the payment code value exceeds the invoice amount.
     * - `'code'` (default) — relayer pays the merchant, then generates a new payment
     *    code for the remainder and returns it as `result.changeCode`. Works even when
     *    the buyer has no wallet (pure code-based flow).
     * - `'wallet'` — uses `settler.settleExact()` on-chain: merchant receives exact
     *    invoice amount, surplus is returned atomically to the buyer's wallet (`from`).
     *    Requires the payment code was created with `to = settler` (atomic mode).
     *
     * Set `allowOverpayment: false` to throw instead of handling the difference.
     */
    returnChange?: 'code' | 'wallet';
    /**
     * If false, throws when code value ≠ invoice amount (strict match).
     * Default: true — difference is handled per `returnChange`.
     */
    allowOverpayment?: boolean;
}
declare function payPayRequestWithCode(config: PaymentRequestConfig, 
/** The merchant's payment request code */
requestCode: string, 
/** The buyer's pre-generated BLIK-style payment code */
paymentCode: string, options?: PayPayRequestWithCodeOptions): Promise<RedeemResult>;
/**
 * Pay a merchant's payment request using a Solana wallet.
 * Cross-chain flow: buyer pays USDC on Solana, merchant receives USDC on Base/SKALE.
 * No EVM wallet required for the buyer — only a Solana wallet adapter.
 *
 * The relayer sponsors Solana gas and bridges the payment to the merchant's EVM network.
 *
 * @example Agent/buyer pays with Solana wallet:
 * ```ts
 * // wallet = any Solana wallet adapter (Phantom, Backpack, private key, etc.)
 * const result = await payPayRequestWithSolana(config, 'MW78SGTW', wallet);
 * console.log('Solana tx:', result.solanaExplorerUrl);
 * console.log('Merchant received on Base:', result.explorerUrl);
 * ```
 */
declare function payPayRequestWithSolana(config: PaymentRequestConfig, requestCode: string, wallet: SolanaWalletAdapter$1, options?: SolanaPayRequestOptions): Promise<SolanaPayRequestResult>;

/**
 * Solana Payment Codes — trustless BLIK-style codes via Anchor on-chain escrow
 *
 * Trustless model (PDA vault, no custodian needed):
 *   1. generateSolanaPaymentCode() — builds create_vault Anchor instruction,
 *      buyer signs, relayer co-signs as feePayer, USDC moves to on-chain PDA vault
 *   2. getSolanaPaymentCode()      — reads on-chain vault state
 *   3. redeemSolanaPaymentCode()   — backend calls redeem_vault (permissionless)
 *   4. cancelSolanaPaymentCode()   — buyer signs cancel_vault, relayer co-signs + broadcasts
 *
 * Comparison to EVM payment codes:
 *   EVM   — EIP-3009 pre-authorisation (lazy, USDC never moves until settlement)
 *   Solana — Anchor PDA vault (USDC locked on-chain, no custodian holds it)
 */

interface SolanaCodeConfig extends PaymentRequestConfig {
}
interface GenerateSolanaPaymentCodeParams {
    /** Amount in USDC micro-units (6 decimals), e.g. 1_000_000 = $1.00 */
    amount: number | bigint;
    /** Solana network (default: auto-detected from relayer-info) */
    network?: "solana" | "solana-devnet";
    /** Solana RPC URL (default: public mainnet/devnet endpoint) */
    solanaRpcUrl?: string;
    /** Code TTL in seconds (min 60, max 604800 = 7 days, default 86400 = 24 h) */
    ttlSeconds?: number;
    /** Create a private claim link instead of returning a visible code */
    claimLink?: boolean;
    /** Optional facilitator-side description associated with the code */
    description?: string;
}
interface SolanaPaymentCode {
    /** 8-char alphanumeric code, e.g. "X7K9P2AB" */
    code: string;
    /** Unix timestamp when the code expires */
    validUntil: number;
    /** Amount in µUSDC (6 decimals) */
    amount: string;
    /** Solana network */
    network: string;
    /** Solscan explorer link for the funding transaction */
    explorerUrl: string;
}
interface SolanaClaimLink {
    [key: string]: unknown;
    validUntil: number;
    amount: string;
    network: string;
    explorerUrl: string;
    claimLink: true;
    claimToken?: string;
    claimUrl?: string | null;
    description?: string | null;
}
interface SolanaPaymentCodeBatchResult {
    registered: number;
    fundingTxHash: string;
    explorerUrl: string;
    network: string;
    totalAmount: string;
    codes: SolanaPaymentCode[];
    failed?: Array<{
        index: number;
        error: string;
    }>;
}
interface SolanaCodeStatus {
    code: string;
    amount: string;
    /** Buyer's Solana address (who funded the code) */
    from: string | null;
    network: string;
    /** "funded" | "redeemed" | "cancelled" | "expired" | "not-found" */
    status: string;
    redeemable: boolean;
    /** On-chain vault PDA address */
    vaultPda: string;
    createdAt: number | null;
    validUntil: number | null;
    fundingTxHash: string | null;
}
interface SolanaCodeRedeemResult {
    success: boolean;
    code: string;
    redeemTxHash: string;
    explorerUrl: string;
    amount: string;
    payee: string;
    network: string;
}
interface SolanaCodeCancelResult {
    success: boolean;
    code: string;
    cancelTxHash: string;
    explorerUrl: string;
    network: string;
}
interface SolanaWalletAdapter {
    publicKey: {
        toString(): string;
    } | null;
    signTransaction<T>(transaction: T): Promise<T>;
}
/**
 * Generate a trustless BLIK-style Solana payment code.
 *
 * Builds an Anchor `create_vault` instruction: USDC moves from buyer ATA
 * into an on-chain PDA vault.  The relayer co-signs only as feePayer;
 * it cannot access the vault — only the redeem/cancel instructions can.
 *
 * @example Agent pre-funds a payment code on Solana Devnet:
 * ```ts
 * const { code } = await generateSolanaPaymentCode(config, wallet, {
 *   amount:  5_000_000,     // $5.00 USDC
 *   network: 'solana-devnet',
 * });
 * console.log('Share this code:', code); // "ABCD1234"
 * ```
 */
declare function generateSolanaPaymentCode(config: SolanaCodeConfig, wallet: SolanaWalletAdapter, params: GenerateSolanaPaymentCodeParams): Promise<SolanaPaymentCode | SolanaClaimLink>;
/**
 * Get the current status of a Solana payment code.
 */
declare function getSolanaPaymentCode(config: SolanaCodeConfig, code: string): Promise<SolanaCodeStatus>;
/**
 * Redeem a Solana payment code — transfer USDC from relayer's escrow to `payee`.
 * `payee` is a base58 Solana address.
 *
 * @example Merchant redeems a code they received:
 * ```ts
 * const result = await redeemSolanaPaymentCode(config, 'ABCD1234', merchantSolanaAddress);
 * console.log('Redeemed! tx:', result.explorerUrl);
 * ```
 */
declare function redeemSolanaPaymentCode(config: SolanaCodeConfig, code: string, payee: string): Promise<SolanaCodeRedeemResult>;
/**
 * Cancel a Solana payment code — returns USDC from the PDA vault back to the buyer.
 *
 * The buyer must sign the `cancel_vault` transaction (only the original buyer can cancel).
 * The relayer co-signs as feePayer so the buyer doesn't need SOL for gas.
 *
 * @param wallet - The buyer's Solana wallet (must be the original code creator)
 */
declare function cancelSolanaPaymentCode(config: SolanaCodeConfig, code: string, wallet: SolanaWalletAdapter, options?: {
    solanaRpcUrl?: string;
    network?: 'solana' | 'solana-devnet';
}): Promise<SolanaCodeCancelResult>;

type CurrentPaymentCodeNetwork = PaymentCodeNetwork | 'solana' | 'solana-devnet';
interface EvmCurrentPaymentCodeSigner extends PaymentCodeSigner {
    signMessage(message: string): Promise<string>;
    sendTransaction?(tx: {
        to: string;
        data: string;
    }): Promise<{
        hash: string;
        wait(): Promise<unknown>;
    }>;
}
interface SolanaCurrentPaymentCodeWallet {
    publicKey: {
        toString(): string;
    } | null;
    signTransaction<T>(transaction: T): Promise<T>;
    signMessage?(message: Uint8Array): Promise<Uint8Array>;
}
interface CreatePaymentCodeParamsBase {
    amount: number | bigint;
    ttlSeconds?: number;
    description?: string;
    claimLink?: boolean;
}
interface CreateEvmPaymentCodeParams extends CreatePaymentCodeParamsBase {
    signer: PaymentCodeSigner;
    network?: PaymentCodeNetwork;
    payee?: string;
    usdcContract?: string;
}
interface CreateSolanaPaymentCodeParams extends CreatePaymentCodeParamsBase {
    network: 'solana' | 'solana-devnet';
    wallet: SolanaCurrentPaymentCodeWallet;
}
type CreatePaymentCodeParams = CreateEvmPaymentCodeParams | CreateSolanaPaymentCodeParams;
interface CreatePaymentCodesBatchItem {
    amount: number | bigint;
    ttlSeconds?: number;
    description?: string;
}
interface CreateEvmPaymentCodesBatchParams {
    signer: PaymentCodeSigner;
    network?: PaymentCodeNetwork;
    payee?: string;
    usdcContract?: string;
    codes: CreatePaymentCodesBatchItem[];
}
interface CreateSolanaPaymentCodesBatchParams {
    network: 'solana' | 'solana-devnet';
    wallet: SolanaCurrentPaymentCodeWallet;
    codes: CreatePaymentCodesBatchItem[];
}
type CreatePaymentCodesBatchParams = CreateEvmPaymentCodesBatchParams | CreateSolanaPaymentCodesBatchParams;
interface ListOwnerPaymentCodesParamsEvm {
    walletType: 'evm';
    wallet: EvmCurrentPaymentCodeSigner;
}
interface ListOwnerPaymentCodesParamsSolana {
    walletType: 'solana';
    wallet: SolanaCurrentPaymentCodeWallet & {
        signMessage(message: Uint8Array): Promise<Uint8Array>;
    };
}
type ListOwnerPaymentCodesParams = ListOwnerPaymentCodesParamsEvm | ListOwnerPaymentCodesParamsSolana;
interface RedeemStoredPaymentCodeParams {
    payee: string;
    evmNetwork?: PaymentCodeNetwork;
    solanaNetwork?: 'solana' | 'solana-devnet';
}
interface CancelStoredPaymentCodeParams {
    wallet?: EvmCurrentPaymentCodeSigner;
    solanaWallet?: SolanaCurrentPaymentCodeWallet;
    network?: CurrentPaymentCodeNetwork;
}
type ClaimPaymentLinkMode = 'claim-usdc' | 'claim-code';
interface ClaimPaymentLinkParamsBase {
    mode?: ClaimPaymentLinkMode;
    payee?: string;
    evmNetwork?: PaymentCodeNetwork;
    solanaNetwork?: 'solana' | 'solana-devnet';
}
interface ClaimPaymentLinkParamsEvm extends ClaimPaymentLinkParamsBase {
    wallet: EvmCurrentPaymentCodeSigner;
    solanaWallet?: never;
}
interface ClaimPaymentLinkParamsSolana extends ClaimPaymentLinkParamsBase {
    wallet?: never;
    solanaWallet: SolanaCurrentPaymentCodeWallet & {
        signMessage(message: Uint8Array): Promise<Uint8Array>;
    };
}
type ClaimPaymentLinkParams = ClaimPaymentLinkParamsEvm | ClaimPaymentLinkParamsSolana;
interface PayPayRequestWithStoredCodeOptions {
    allowOverpayment?: boolean;
    returnChange?: 'code' | 'wallet';
    changeAddress?: string;
}
type CurrentPaymentCodeResponse = Record<string, unknown> | SolanaPaymentCode | SolanaClaimLink;
type OwnerPaymentCodesResponse = Record<string, unknown>;
type PaymentCodeDetailsResponse = Record<string, unknown>;
type RedeemStoredPaymentCodeResponse = Record<string, unknown>;
type CancelStoredPaymentCodeResponse = Record<string, unknown> | SolanaCodeCancelResult;
type ClaimPaymentLinkResponse = Record<string, unknown>;
type PayPayRequestWithStoredCodeResponse = Record<string, unknown>;
type PaymentCodesBatchResponse = Record<string, unknown> | SolanaPaymentCodeBatchResult;
declare function createPaymentCode(config: PaymentCodeConfig, params: CreatePaymentCodeParams): Promise<CurrentPaymentCodeResponse>;
declare function createPaymentCodesBatch(config: PaymentCodeConfig, params: CreatePaymentCodesBatchParams): Promise<PaymentCodesBatchResponse>;
declare function listOwnerPaymentCodes(config: PaymentCodeConfig, params: ListOwnerPaymentCodesParams): Promise<OwnerPaymentCodesResponse>;
declare function getPaymentCode(config: PaymentCodeConfig, code: string): Promise<PaymentCodeDetailsResponse>;
declare const getPaymentCodeDetails: typeof getPaymentCode;
declare function redeemStoredPaymentCode(config: PaymentCodeConfig, code: string, params: RedeemStoredPaymentCodeParams): Promise<RedeemStoredPaymentCodeResponse>;
declare function cancelStoredPaymentCode(config: PaymentCodeConfig, code: string, params?: CancelStoredPaymentCodeParams): Promise<CancelStoredPaymentCodeResponse>;
declare function claimPaymentLink(config: PaymentCodeConfig, claimUrlOrToken: string, params: ClaimPaymentLinkParams): Promise<ClaimPaymentLinkResponse>;
declare function payPayRequestWithStoredCode(config: PaymentRequestConfig, requestCode: string, paymentCode: string, options?: PayPayRequestWithStoredCodeOptions): Promise<PayPayRequestWithStoredCodeResponse>;

export { type BatchCodeItem, type BatchPaymentCodesResult, type CancelStoredPaymentCodeParams, type CancelStoredPaymentCodeResponse, type ClaimPaymentLinkMode, type ClaimPaymentLinkParams, type ClaimPaymentLinkResponse, type CodeStatus, type CreatePayRequestParams, type CreatePaymentCodeParams, type CreatePaymentCodesBatchItem, type CreatePaymentCodesBatchParams, type CurrentPaymentCodeNetwork, type CurrentPaymentCodeResponse, type EvmCurrentPaymentCodeSigner, type GeneratePaymentCodeParams, type GeneratePaymentCodesBatchParams, type GenerateSolanaPaymentCodeParams, type ListOwnerPaymentCodesParams, NETWORK_CONFIGS, type NetworkConfig, type OwnerPaymentCodesResponse, type PayPayRequestWithCodeOptions, type PayPayRequestWithStoredCodeOptions, type PayPayRequestWithStoredCodeResponse, type PayRequest, type PayRequestInfo, type PayRequestResult, type PaymentCode, type PaymentCodeConfig, type PaymentCodeDetailsResponse, type PaymentCodeNetwork, type PaymentCodeSigner, type PaymentCodesBatchResponse, type PaymentRequestConfig, type PaymentRequestNetwork, type RedeemResult, type RedeemStoredPaymentCodeParams, type RedeemStoredPaymentCodeResponse, type SolanaClaimLink, type SolanaCodeCancelResult, type SolanaCodeConfig, type SolanaCodeRedeemResult, type SolanaCodeStatus, type SolanaCurrentPaymentCodeWallet, type SolanaPayRequestOptions, type SolanaPayRequestResult, type SolanaPaymentCode, type SolanaWalletAdapter$1 as SolanaWalletAdapter, cancelPaymentCode, cancelSolanaPaymentCode, cancelStoredPaymentCode, claimPaymentLink, createPayRequest, createPaymentCode, createPaymentCodesBatch, createPrivateKeySigner, generatePaymentCode, generatePaymentCodesBatch, generateSolanaPaymentCode, getPayRequest, getPaymentCode$1 as getPaymentCode, getPaymentCodeDetails, getSolanaPaymentCode, listOwnerPaymentCodes, payPayRequest, payPayRequestWithCode, payPayRequestWithSolana, payPayRequestWithStoredCode, redeemPaymentCode, redeemSolanaPaymentCode, redeemStoredPaymentCode };