import { z } from 'zod';
import * as crypto from 'crypto';

type SourceData = Uint8Array | string;
declare function createSha256Hash(data: SourceData): Promise<Uint8Array>;
declare function createSha256Hash(data: SourceData, asHex: true): Promise<string>;

/**
 * Generated error codes - DO NOT MODIFY MANUALLY
 */
interface ErrorDetails {
    code: string;
    httpStatusCode: number;
}
declare const ErrorCode: {
    /** Error fetching counterparty public key for validating signatures or encrypting messages */
    readonly COUNTERPARTY_PUBKEY_FETCH_ERROR: {
        readonly code: "COUNTERPARTY_PUBKEY_FETCH_ERROR";
        readonly httpStatusCode: 424;
    };
    /** Error parsing the counterparty public key response */
    readonly INVALID_PUBKEY_FORMAT: {
        readonly code: "INVALID_PUBKEY_FORMAT";
        readonly httpStatusCode: 400;
    };
    /** The provided certificate chain is invalid */
    readonly CERT_CHAIN_INVALID: {
        readonly code: "CERT_CHAIN_INVALID";
        readonly httpStatusCode: 400;
    };
    /** The provided certificate chain has expired */
    readonly CERT_CHAIN_EXPIRED: {
        readonly code: "CERT_CHAIN_EXPIRED";
        readonly httpStatusCode: 400;
    };
    /** The provided signature is not valid */
    readonly INVALID_SIGNATURE: {
        readonly code: "INVALID_SIGNATURE";
        readonly httpStatusCode: 401;
    };
    /** The provided timestamp is not valid */
    readonly INVALID_TIMESTAMP: {
        readonly code: "INVALID_TIMESTAMP";
        readonly httpStatusCode: 400;
    };
    /** The provided nonce is not valid */
    readonly INVALID_NONCE: {
        readonly code: "INVALID_NONCE";
        readonly httpStatusCode: 400;
    };
    /** An unexpected error occurred on the server */
    readonly INTERNAL_ERROR: {
        readonly code: "INTERNAL_ERROR";
        readonly httpStatusCode: 500;
    };
    /** This party does not support non-UMA LNURLs */
    readonly NON_UMA_LNURL_NOT_SUPPORTED: {
        readonly code: "NON_UMA_LNURL_NOT_SUPPORTED";
        readonly httpStatusCode: 403;
    };
    /** Missing required UMA parameters */
    readonly MISSING_REQUIRED_UMA_PARAMETERS: {
        readonly code: "MISSING_REQUIRED_UMA_PARAMETERS";
        readonly httpStatusCode: 400;
    };
    /** The counterparty UMA version is not supported */
    readonly UNSUPPORTED_UMA_VERSION: {
        readonly code: "UNSUPPORTED_UMA_VERSION";
        readonly httpStatusCode: 412;
    };
    /** Error parsing the LNURLP request */
    readonly PARSE_LNURLP_REQUEST_ERROR: {
        readonly code: "PARSE_LNURLP_REQUEST_ERROR";
        readonly httpStatusCode: 400;
    };
    /** This user has exceeded the velocity limit and is unable to receive payments at this time */
    readonly VELOCITY_LIMIT_EXCEEDED: {
        readonly code: "VELOCITY_LIMIT_EXCEEDED";
        readonly httpStatusCode: 403;
    };
    /** The user for this UMA was not found */
    readonly USER_NOT_FOUND: {
        readonly code: "USER_NOT_FOUND";
        readonly httpStatusCode: 404;
    };
    /** The user for this UMA is not ready to receive payments at this time */
    readonly USER_NOT_READY: {
        readonly code: "USER_NOT_READY";
        readonly httpStatusCode: 403;
    };
    /** The request corresponding to this callback URL was not found */
    readonly REQUEST_NOT_FOUND: {
        readonly code: "REQUEST_NOT_FOUND";
        readonly httpStatusCode: 404;
    };
    /** Error parsing the payreq request */
    readonly PARSE_PAYREQ_REQUEST_ERROR: {
        readonly code: "PARSE_PAYREQ_REQUEST_ERROR";
        readonly httpStatusCode: 400;
    };
    /** The amount provided is not within the min/max range */
    readonly AMOUNT_OUT_OF_RANGE: {
        readonly code: "AMOUNT_OUT_OF_RANGE";
        readonly httpStatusCode: 400;
    };
    /** The currency provided is not valid or supported */
    readonly INVALID_CURRENCY: {
        readonly code: "INVALID_CURRENCY";
        readonly httpStatusCode: 400;
    };
    /** Payments from this sender are not accepted */
    readonly SENDER_NOT_ACCEPTED: {
        readonly code: "SENDER_NOT_ACCEPTED";
        readonly httpStatusCode: 400;
    };
    /** Payer data is missing fields that are required by the receiver */
    readonly MISSING_MANDATORY_PAYER_DATA: {
        readonly code: "MISSING_MANDATORY_PAYER_DATA";
        readonly httpStatusCode: 400;
    };
    /** Receiver does not recognize the mandatory payee data key */
    readonly UNRECOGNIZED_MANDATORY_PAYEE_DATA_KEY: {
        readonly code: "UNRECOGNIZED_MANDATORY_PAYEE_DATA_KEY";
        readonly httpStatusCode: 501;
    };
    /** Error parsing the utxo callback */
    readonly PARSE_UTXO_CALLBACK_ERROR: {
        readonly code: "PARSE_UTXO_CALLBACK_ERROR";
        readonly httpStatusCode: 400;
    };
    /** This party does not accept payments with the counterparty */
    readonly COUNTERPARTY_NOT_ALLOWED: {
        readonly code: "COUNTERPARTY_NOT_ALLOWED";
        readonly httpStatusCode: 403;
    };
    /** Error parsing the LNURLP response */
    readonly PARSE_LNURLP_RESPONSE_ERROR: {
        readonly code: "PARSE_LNURLP_RESPONSE_ERROR";
        readonly httpStatusCode: 400;
    };
    /** Error parsing the payreq response */
    readonly PARSE_PAYREQ_RESPONSE_ERROR: {
        readonly code: "PARSE_PAYREQ_RESPONSE_ERROR";
        readonly httpStatusCode: 400;
    };
    /** The LNURLP request failed */
    readonly LNURLP_REQUEST_FAILED: {
        readonly code: "LNURLP_REQUEST_FAILED";
        readonly httpStatusCode: 424;
    };
    /** The payreq request failed */
    readonly PAYREQ_REQUEST_FAILED: {
        readonly code: "PAYREQ_REQUEST_FAILED";
        readonly httpStatusCode: 424;
    };
    /** No compatible UMA protocol version found between sender and receiver */
    readonly NO_COMPATIBLE_UMA_VERSION: {
        readonly code: "NO_COMPATIBLE_UMA_VERSION";
        readonly httpStatusCode: 424;
    };
    /** The provided invoice is invalid */
    readonly INVALID_INVOICE: {
        readonly code: "INVALID_INVOICE";
        readonly httpStatusCode: 400;
    };
    /** The invoice has expired */
    readonly INVOICE_EXPIRED: {
        readonly code: "INVOICE_EXPIRED";
        readonly httpStatusCode: 400;
    };
    /** The quote has expired */
    readonly QUOTE_EXPIRED: {
        readonly code: "QUOTE_EXPIRED";
        readonly httpStatusCode: 400;
    };
    /** The provided input is invalid */
    readonly INVALID_INPUT: {
        readonly code: "INVALID_INPUT";
        readonly httpStatusCode: 400;
    };
    /** The request format is invalid */
    readonly INVALID_REQUEST_FORMAT: {
        readonly code: "INVALID_REQUEST_FORMAT";
        readonly httpStatusCode: 400;
    };
    /** This action is not permitted for this user */
    readonly FORBIDDEN: {
        readonly code: "FORBIDDEN";
        readonly httpStatusCode: 403;
    };
    /** This functionality is not implemented */
    readonly NOT_IMPLEMENTED: {
        readonly code: "NOT_IMPLEMENTED";
        readonly httpStatusCode: 501;
    };
    /** The requested quote was not found */
    readonly QUOTE_NOT_FOUND: {
        readonly code: "QUOTE_NOT_FOUND";
        readonly httpStatusCode: 404;
    };
};

declare const isError: (e: unknown) => e is Error;
declare class UmaError extends Error {
    readonly code: string;
    readonly httpStatusCode: number;
    constructor(message: string, error: ErrorDetails);
    getAdditionalParams(): Record<string, unknown>;
    toJSON(): string;
    toHttpStatusCode(): number;
}
declare class InvalidInputError extends UmaError {
    constructor(message: string, error: ErrorDetails);
}

/**
 * Interface for a class which can validate nonces to ensure that the same nonce isn't re-used between requests.
 */
interface NonceValidator {
    /**
     * Checks if the nonce has been used before and saves it if it has not.
     *
     * @param nonce The nonce to check.
     * @param timestamp The timestamp of the message which was included in the signed payload with the nonce.
     *    This can be used to clear out old nonces if desired.
     * @returns true if the nonce was valid and has not been used before, false otherwise.
     */
    checkAndSaveNonce(nonce: string, timestamp: number): Promise<boolean>;
}
/**
 * A simple in-memory nonce validator which caches seen nonce values and rejects any which have been seen before
 * or which are older than a specified limit timestamp. It is not recommended to use this in production, as it will not
 * persist across restarts. You likely want to implement your own validator that persists to a database of some sort.
 */
declare class InMemoryNonceValidator implements NonceValidator {
    private oldestValidTimestampMs;
    constructor(oldestValidTimestampMs: number);
    private seenNoncesTimestamps;
    checkAndSaveNonce(nonce: string, timestampSec: number): Promise<boolean>;
    /**
     * Purges all nonces older than the given timestamp. This allows the cache to be pruned.
     *
     * @param timestamp A timestamp value in ms before which all nonces should be purged.
     */
    purgeNoncesOlderThan(timestampMs: number): Promise<void>;
}

declare const CounterPartyDataOptionSchema: z.ZodObject<{
    mandatory: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    mandatory: boolean;
}, {
    mandatory: boolean;
}>;
type CounterPartyDataOption = z.infer<typeof CounterPartyDataOptionSchema>;
/**
 * CounterPartyDataOptions describes which fields a vasp needs to know about the sender or receiver.
 * Used for payerData and payeeData.
 */
declare const CounterPartyDataOptionsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
    mandatory: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    mandatory: boolean;
}, {
    mandatory: boolean;
}>>;
type CounterPartyDataOptions = z.infer<typeof CounterPartyDataOptionsSchema>;
/**
 * this function serializes CounterPartyDataOptions into bytes.  The options are sorted
 * to match other platforms
 * @param options - incoming CounterPartyDataOptions
 * @returns Uint8Array representing byte encoded string of options
 */
declare function counterPartyDataOptionsToBytes(options: CounterPartyDataOptions): Uint8Array;
declare function counterPartyDataOptionsFromBytes(bytes: Uint8Array): CounterPartyDataOptions;

/**
 * Common keys used in counterparty data exchanges between VASPs.
 */
declare const CounterPartyDataKeys: {
    /** The UMA address of the counterparty */
    readonly IDENTIFIER: "identifier";
    /** The full name of the counterparty */
    readonly NAME: "name";
    /** The email address of the counterparty */
    readonly EMAIL: "email";
    /** Compliance-related data including KYC status, UTXOs, and travel rule information */
    readonly COMPLIANCE: "compliance";
    /** The counterparty's date of birth, in ISO 8601 format */
    readonly BIRTH_DATE: "birthDate";
    /** The counterparty's nationality, in ISO 3166-1 alpha-2 format */
    readonly NATIONALITY: "nationality";
    /** The counterparty's country of residence, in ISO 3166-1 alpha-2 format */
    readonly COUNTRY_OF_RESIDENCE: "countryOfResidence";
    /** The counterparty's phone number, in E.164 format */
    readonly PHONE_NUMBER: "phoneNumber";
};
type CounterPartyDataKey = (typeof CounterPartyDataKeys)[keyof typeof CounterPartyDataKeys];

declare class Currency {
    /**
     * The currency code, eg. "USD".
     */
    readonly code: string;
    /**
     * The full currency name in plural form, eg. "US Dollars".
     */
    readonly name: string;
    /**
     * The symbol of the currency, eg. "$".
     */
    readonly symbol: string;
    /**
     * Estimated millisats per smallest "unit" of this currency (eg. 1 cent in USD).
     */
    readonly multiplier: number;
    /**
     * Minimum amount that can be sent in this currency. This is in the smallest unit of the currency
     * (eg. cents for USD).
     */
    readonly minSendable: number;
    /**
     * Maximum amount that can be sent in this currency. This is in the smallest unit of the currency
     * (eg. cents for USD).
     */
    readonly maxSendable: number;
    /**
     * The number of digits after the decimal point for display on the sender side, and to add clarity
     * around what the "smallest unit" of the currency is. For example, in USD, by convention, there are 2 digits for
     * cents - $5.95. In this case, `decimals` would be 2. Note that the multiplier is still always in the smallest
     * unit (cents). In addition to display purposes, this field can be used to resolve ambiguity in what the multiplier
     * means. For example, if the currency is "BTC" and the multiplier is 1000, really we're exchanging in SATs, so
     * `decimals` would be 8.
     * For details on edge cases and examples, see https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md.
     */
    readonly decimals: number;
    /** The major version of the UMA protocol that this currency adheres to. This is not serialized to JSON. */
    readonly umaVersion: number;
    constructor(
    /**
     * The currency code, eg. "USD".
     */
    code: string, 
    /**
     * The full currency name in plural form, eg. "US Dollars".
     */
    name: string, 
    /**
     * The symbol of the currency, eg. "$".
     */
    symbol: string, 
    /**
     * Estimated millisats per smallest "unit" of this currency (eg. 1 cent in USD).
     */
    multiplier: number, 
    /**
     * Minimum amount that can be sent in this currency. This is in the smallest unit of the currency
     * (eg. cents for USD).
     */
    minSendable: number, 
    /**
     * Maximum amount that can be sent in this currency. This is in the smallest unit of the currency
     * (eg. cents for USD).
     */
    maxSendable: number, 
    /**
     * The number of digits after the decimal point for display on the sender side, and to add clarity
     * around what the "smallest unit" of the currency is. For example, in USD, by convention, there are 2 digits for
     * cents - $5.95. In this case, `decimals` would be 2. Note that the multiplier is still always in the smallest
     * unit (cents). In addition to display purposes, this field can be used to resolve ambiguity in what the multiplier
     * means. For example, if the currency is "BTC" and the multiplier is 1000, really we're exchanging in SATs, so
     * `decimals` would be 8.
     * For details on edge cases and examples, see https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md.
     */
    decimals: number, 
    /** The major version of the UMA protocol that this currency adheres to. This is not serialized to JSON. */
    umaVersion?: number);
    static parse(data: any): Currency;
    toJsonSchemaObject(): z.infer<typeof V0CurrencySchema> | z.infer<typeof V1CurrencySchema>;
    toJsonString(): string;
    toJSON(): string;
    withUmaVersion(majorVersion: number): Currency;
}
declare const V1CurrencySchema: z.ZodObject<{
    code: z.ZodString;
    name: z.ZodString;
    symbol: z.ZodString;
    multiplier: z.ZodNumber;
    decimals: z.ZodNumber;
    convertible: z.ZodObject<{
        min: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        min: number;
        max: number;
    }, {
        min: number;
        max: number;
    }>;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    convertible: {
        min: number;
        max: number;
    };
}, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    convertible: {
        min: number;
        max: number;
    };
}>;
declare const V0CurrencySchema: z.ZodObject<{
    code: z.ZodString;
    name: z.ZodString;
    symbol: z.ZodString;
    multiplier: z.ZodNumber;
    minSendable: z.ZodNumber;
    maxSendable: z.ZodNumber;
    decimals: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    minSendable: number;
    maxSendable: number;
}, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    minSendable: number;
    maxSendable: number;
}>;
declare const CurrencySchema: z.ZodEffects<z.ZodUnion<[z.ZodObject<{
    code: z.ZodString;
    name: z.ZodString;
    symbol: z.ZodString;
    multiplier: z.ZodNumber;
    decimals: z.ZodNumber;
    convertible: z.ZodObject<{
        min: z.ZodNumber;
        max: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        min: number;
        max: number;
    }, {
        min: number;
        max: number;
    }>;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    convertible: {
        min: number;
        max: number;
    };
}, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    convertible: {
        min: number;
        max: number;
    };
}>, z.ZodObject<{
    code: z.ZodString;
    name: z.ZodString;
    symbol: z.ZodString;
    multiplier: z.ZodNumber;
    minSendable: z.ZodNumber;
    maxSendable: z.ZodNumber;
    decimals: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    minSendable: number;
    maxSendable: number;
}, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    minSendable: number;
    maxSendable: number;
}>]>, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    minSendable: number;
    maxSendable: number;
} & {
    umaVersion: number;
}, {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    convertible: {
        min: number;
        max: number;
    };
} | {
    symbol: string;
    name: string;
    code: string;
    multiplier: number;
    decimals: number;
    minSendable: number;
    maxSendable: number;
}>;

declare enum KycStatus {
    Unknown = "UNKNOWN",
    NotVerified = "NOT_VERIFIED",
    Pending = "PENDING",
    Verified = "VERIFIED"
}
declare function kycStatusFromString(s: string): KycStatus;
declare function kycStatusToString(k: KycStatus): string;
declare function kycStatusToBytes(k: KycStatus): Uint8Array;
declare function kycStatusFromBytes(bytes: Uint8Array): KycStatus;

declare const InvoiceCurrencySchema: z.ZodObject<{
    name: z.ZodString;
    code: z.ZodString;
    symbol: z.ZodString;
    decimals: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    symbol: string;
    name: string;
    code: string;
    decimals: number;
}, {
    symbol: string;
    name: string;
    code: string;
    decimals: number;
}>;
/**
 * Sub object describing receiving currency in more detail
 *
 * @param name
 * @param code
 * @param symbol
 * @param decimals
 */
type InvoiceCurrency = z.infer<typeof InvoiceCurrencySchema>;
declare const InvoiceSchema: z.ZodObject<{
    receiverUma: z.ZodString;
    invoiceUUID: z.ZodString;
    amount: z.ZodNumber;
    receivingCurrency: z.ZodObject<{
        name: z.ZodString;
        code: z.ZodString;
        symbol: z.ZodString;
        decimals: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        symbol: string;
        name: string;
        code: string;
        decimals: number;
    }, {
        symbol: string;
        name: string;
        code: string;
        decimals: number;
    }>;
    expiration: z.ZodNumber;
    isSubjectToTravelRule: z.ZodBoolean;
    requiredPayerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    umaVersions: z.ZodString;
    commentCharsAllowed: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<number, z.ZodTypeDef, number>>, number | undefined, number | null>>;
    senderUma: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    maxNumPayments: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<number, z.ZodTypeDef, number>>, number | undefined, number | null>>;
    kycStatus: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<KycStatus, z.ZodTypeDef, KycStatus>>, NonNullable<KycStatus> | undefined, KycStatus | null>>;
    callback: z.ZodString;
    signature: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>>, Uint8Array | undefined, Uint8Array | null>>;
}, "strip", z.ZodTypeAny, {
    receiverUma: string;
    invoiceUUID: string;
    amount: number;
    receivingCurrency: {
        symbol: string;
        name: string;
        code: string;
        decimals: number;
    };
    expiration: number;
    isSubjectToTravelRule: boolean;
    umaVersions: string;
    callback: string;
    requiredPayerData?: Record<string, {
        mandatory: boolean;
    }> | undefined;
    commentCharsAllowed?: number | undefined;
    senderUma?: string | undefined;
    maxNumPayments?: number | undefined;
    kycStatus?: NonNullable<KycStatus> | undefined;
    signature?: Uint8Array | undefined;
}, {
    receiverUma: string;
    invoiceUUID: string;
    amount: number;
    receivingCurrency: {
        symbol: string;
        name: string;
        code: string;
        decimals: number;
    };
    expiration: number;
    isSubjectToTravelRule: boolean;
    umaVersions: string;
    callback: string;
    requiredPayerData?: Record<string, {
        mandatory: boolean;
    }> | null | undefined;
    commentCharsAllowed?: number | null | undefined;
    senderUma?: string | null | undefined;
    maxNumPayments?: number | null | undefined;
    kycStatus?: KycStatus | null | undefined;
    signature?: Uint8Array | null | undefined;
}>;
/**
 * Invoice
 * represents a UMA invoice
 *
 * @param receiverUma
 * @param invoiceUUID - Invoice UUID Served as both the identifier of the UMA invoice, and the validation of proof of payment
 * @param amount - The amount of invoice to be paid in the smallest unit of the ReceivingCurrency.
 * @param receivingCurrency - The currency of the invoice
 * @param expiration - The unix timestamp of when the UMA invoice expires
 * @param isSubjectToTravelRule -  Indicates whether the VASP is a financial institution that requires travel rule information.
 * @param requiredPayerData - the data about the payer that the sending VASP must provide in order to send a payment
 * @param umaVersions - UmaVersions is a list of UMA versions that the VASP supports for this transaction. It should
 * contain the lowest minor version of each major version it supported, separated by commas
 * @param commentCharsAllowed - is the number of characters that the sender can include in the comment field of the pay request.
 * @param senderUma - The sender's UMA address. If this field presents, the UMA invoice should directly go to the sending VASP
 * instead of showing in other formats
 * @param maxNumPayments - The maximum number of times the invoice can be paid
 * @param kycStatus - YC status of the receiver, default is verified
 * @param callback - The callback url that the sender should send the PayRequest to
 * @param signature - The signature of the UMA invoice
 */
type Invoice = z.infer<typeof InvoiceSchema>;
type TLVSerial<T> = {
    tag: number;
    serialize: (value: T) => Uint8Array;
    deserialize: (bytes: Uint8Array) => T;
};
/**
 * Serializer object converts Invoice to Uint8Array in type-length-value format,
 * or creates Invoice based on properly validated Uint8Array
 *
 * additionally, can convert a tlv formatted Invoice into a bech32 string
 */
declare const InvoiceSerializer: {
    serialMap: Map<string, TLVSerial<unknown>>;
    reverseLookupSerialMap: Map<number, string>;
    registerSerializer(field: string, helper: TLVSerial<any>): any;
    toTLV(invoice: Invoice): Uint8Array;
    toBech32(invoice: Invoice, maxLength?: number | undefined): string;
    fromTLV(bytes: Uint8Array): Invoice;
    fromBech32(bech32str: string, maxLength?: number | undefined): Invoice;
};

/**
 * A signature by a backing VASP that can attest to the authenticity of the message,
 * along with its associated domain.
 */
declare const BackingSignatureSchema: z.ZodObject<{
    /**
     * Domain is the domain of the VASP that produced the signature. Public keys for this VASP will be fetched from
     * the domain at /.well-known/lnurlpubkey and used to verify the signature.
     */
    domain: z.ZodString;
    /**
     * Signature is the signature of the payload.
     */
    signature: z.ZodString;
}, "strip", z.ZodTypeAny, {
    signature: string;
    domain: string;
}, {
    signature: string;
    domain: string;
}>;
type BackingSignature = z.infer<typeof BackingSignatureSchema>;

/** LnurlpRequest is the first request in the UMA protocol. It is sent by the VASP that is sending the payment to find out information about the receiver. */
type LnurlpRequest = {
    /** ReceiverAddress is the address of the user at VASP2 that is receiving the payment. */
    receiverAddress: string;
    /** Nonce is a random string that is used to prevent replay attacks. */
    nonce?: string | undefined;
    /** Signature is the base64-encoded signature of sha256(ReceiverAddress|Nonce|Timestamp). */
    signature?: string | undefined;
    /** IsSubjectToTravelRule indicates VASP1 is a financial institution that requires travel rule information. */
    isSubjectToTravelRule?: boolean | undefined;
    /** VaspDomain is the domain of the VASP that is sending the payment. It will be used by VASP2 to fetch the public keys of VASP1. */
    vaspDomain?: string | undefined;
    /** Timestamp is the unix timestamp of when the request was sent. Used in the signature. */
    timestamp?: Date | undefined;
    /**
     * The version of the UMA protocol that VASP2 has chosen for this transaction based on its own support and VASP1's specified preference in the LnurlpRequest.
     * For the version negotiation flow, see https://static.swimlanes.io/87f5d188e080cb8e0494e46f80f2ae74.png
     */
    umaVersion?: string | undefined;
    /** A list of backing signatures from VASPs that can attest to the authenticity of the message. */
    backingSignatures?: BackingSignature[] | undefined;
};
declare function isLnurlpRequestForUma(request: LnurlpRequest): request is LnurlpRequest & {
    receiverAddress: string;
    nonce: string;
    signature: string;
    vaspDomain: string;
    timestamp: Date;
    umaVersion: string;
};
declare function encodeToUrl(q: LnurlpRequest): URL;
declare function getSignableLnurlpRequestPayload(q: LnurlpRequest): string;
/**
 * Adds a backing signature to the request using the provided private key and domain.
 * The signature is created by signing the request's signable payload.
 *
 * @param signingPrivateKey The private key to sign with as a Buffer
 * @param domain The domain associated with the signature
 * @returns A new LnurlpRequest with the additional backing signature
 */
declare function appendBackingSignature(request: LnurlpRequest, signingPrivateKey: Uint8Array, domain: string): Promise<LnurlpRequest>;

declare const SettlementAssetSchema: z.ZodObject<{
    /**
     * The identifier of the asset. For Lightning, this should be "BTC".
     * For Spark, this is the token identifier.
     */
    identifier: z.ZodString;
    /**
     * Estimated conversion rates from this asset to the currencies supported by
     * the receiver. The key is the currency code and the value is the multiplier
     * (how many of the smallest unit of this asset equals one unit of the currency).
     */
    multipliers: z.ZodRecord<z.ZodString, z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    identifier: string;
    multipliers: Record<string, number>;
}, {
    identifier: string;
    multipliers: Record<string, number>;
}>;
type SettlementAsset = z.infer<typeof SettlementAssetSchema>;
declare const SettlementOptionSchema: z.ZodObject<{
    /** The name of the settlement layer (e.g., "spark", "ln"). */
    settlementLayer: z.ZodString;
    /** List of accepted assets on this settlement layer with their conversion rates. */
    assets: z.ZodArray<z.ZodObject<{
        /**
         * The identifier of the asset. For Lightning, this should be "BTC".
         * For Spark, this is the token identifier.
         */
        identifier: z.ZodString;
        /**
         * Estimated conversion rates from this asset to the currencies supported by
         * the receiver. The key is the currency code and the value is the multiplier
         * (how many of the smallest unit of this asset equals one unit of the currency).
         */
        multipliers: z.ZodRecord<z.ZodString, z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        identifier: string;
        multipliers: Record<string, number>;
    }, {
        identifier: string;
        multipliers: Record<string, number>;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    settlementLayer: string;
    assets: {
        identifier: string;
        multipliers: Record<string, number>;
    }[];
}, {
    settlementLayer: string;
    assets: {
        identifier: string;
        multipliers: Record<string, number>;
    }[];
}>;
type SettlementOption = z.infer<typeof SettlementOptionSchema>;
declare const SettlementInfoSchema: z.ZodObject<{
    /** The settlement layer chosen by the sender (e.g., "ln", "spark"). */
    layer: z.ZodString;
    /** The identifier of the settlement asset chosen by the sender. */
    assetIdentifier: z.ZodString;
}, "strip", z.ZodTypeAny, {
    layer: string;
    assetIdentifier: string;
}, {
    layer: string;
    assetIdentifier: string;
}>;
type SettlementInfo = z.infer<typeof SettlementInfoSchema>;

/** The response to the LnurlpRequest. It is sent by the VASP that is receiving the payment to provide information to the sender about the receiver. */
declare class LnurlpResponse {
    /** The URL that the sender will call for the payreq request. */
    callback: string;
    /** The minimum amount that the sender can send in millisatoshis. */
    minSendable: number;
    /** The maximum amount that the sender can send in millisatoshis. */
    maxSendable: number;
    /** JSON-encoded metadata that the sender can use to display information to the user. */
    metadata: string;
    /** Compliance-related data from the receiving VASP. Required for UMA. */
    compliance?: LnurlComplianceResponse | undefined;
    /**
     * The version of the UMA protocol that VASP2 has chosen for this transaction based on its own support and VASP1's specified preference in the LnurlpRequest.
     * For the version negotiation flow, see https://static.swimlanes.io/87f5d188e080cb8e0494e46f80f2ae74.png
     */
    umaVersion?: string | undefined;
    /** The list of currencies that the receiver accepts in order of preference. */
    currencies?: Currency[] | undefined;
    /** The data about the payer that the sending VASP must provide in order to send a payment. */
    payerData?: CounterPartyDataOptions | undefined;
    /**
     * The number of characters that the sender can include in the comment field of the pay request.
     */
    commentAllowed?: number | undefined;
    /**
     * An optional nostr pubkey used for nostr zaps (NIP-57). If set, it should be a valid
     * BIP-340 public key in hex format.
     */
    nostrPubkey?: string | undefined;
    /**
     * Should be set to true if the receiving VASP allows nostr zaps (NIP-57).
     */
    allowsNostr?: boolean | undefined;
    /**
     * The list of settlement options that the receiver supports. If not specified,
     * the payment will be settled on Lightning using BTC as the settlement asset.
     */
    settlementOptions?: SettlementOption[] | undefined;
    tag: string;
    constructor(
    /** The URL that the sender will call for the payreq request. */
    callback: string, 
    /** The minimum amount that the sender can send in millisatoshis. */
    minSendable: number, 
    /** The maximum amount that the sender can send in millisatoshis. */
    maxSendable: number, 
    /** JSON-encoded metadata that the sender can use to display information to the user. */
    metadata: string, 
    /** Compliance-related data from the receiving VASP. Required for UMA. */
    compliance?: LnurlComplianceResponse | undefined, 
    /**
     * The version of the UMA protocol that VASP2 has chosen for this transaction based on its own support and VASP1's specified preference in the LnurlpRequest.
     * For the version negotiation flow, see https://static.swimlanes.io/87f5d188e080cb8e0494e46f80f2ae74.png
     */
    umaVersion?: string | undefined, 
    /** The list of currencies that the receiver accepts in order of preference. */
    currencies?: Currency[] | undefined, 
    /** The data about the payer that the sending VASP must provide in order to send a payment. */
    payerData?: CounterPartyDataOptions | undefined, 
    /**
     * The number of characters that the sender can include in the comment field of the pay request.
     */
    commentAllowed?: number | undefined, 
    /**
     * An optional nostr pubkey used for nostr zaps (NIP-57). If set, it should be a valid
     * BIP-340 public key in hex format.
     */
    nostrPubkey?: string | undefined, 
    /**
     * Should be set to true if the receiving VASP allows nostr zaps (NIP-57).
     */
    allowsNostr?: boolean | undefined, 
    /**
     * The list of settlement options that the receiver supports. If not specified,
     * the payment will be settled on Lightning using BTC as the settlement asset.
     */
    settlementOptions?: SettlementOption[] | undefined);
    isUma(): this is {
        compliance: LnurlComplianceResponse;
        umaVersion: string;
        currencies: Currency[];
        payerData: CounterPartyDataOptions;
    };
    signablePayload(): string;
    toJsonSchemaObject(): z.infer<typeof LnurlpResponseSchema>;
    toJsonString(): string;
    /**
     * Appends a backing signature to the LnurlpResponse.
     *
     * @param signingPrivateKey The private key used to sign the payload
     * @param domain The domain of the VASP that is signing the payload. The associated public key will be fetched from
     *    /.well-known/lnurlpubkey on this domain to verify the signature.
     * @returns A new LnurlpResponse with the additional backing signature
     */
    appendBackingSignature(signingPrivateKey: Uint8Array, domain: string): Promise<LnurlpResponse>;
    static fromJson(jsonStr: string): LnurlpResponse;
    static parse(data: any): LnurlpResponse;
}
/** LnurlComplianceResponse is the `compliance` field  of the LnurlpResponse. */
declare const LnurlpComplianceResponseSchema: z.ZodObject<{
    /** KycStatus indicates whether VASP2 has KYC information about the receiver. */
    kycStatus: z.ZodNativeEnum<typeof KycStatus>;
    /** Signature is the base64-encoded signature of sha256(ReceiverAddress|Nonce|Timestamp). */
    signature: z.ZodString;
    /** Nonce is a random string that is used to prevent replay attacks. */
    signatureNonce: z.ZodString;
    /** Timestamp is the unix timestamp of when the request was sent. Used in the signature. */
    signatureTimestamp: z.ZodNumber;
    /** IsSubjectToTravelRule indicates whether VASP2 is a financial institution that requires travel rule information. */
    isSubjectToTravelRule: z.ZodBoolean;
    /** ReceiverIdentifier is the identifier of the receiver at VASP2. */
    receiverIdentifier: z.ZodString;
    /** BackingSignatures is a list of backing signatures from VASPs that can attest to the authenticity of the message. */
    backingSignatures: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        signature: string;
        domain: string;
    }[], z.ZodTypeDef, {
        signature: string;
        domain: string;
    }[]>>, {
        signature: string;
        domain: string;
    }[] | undefined, {
        signature: string;
        domain: string;
    }[] | null>>;
}, "strip", z.ZodTypeAny, {
    isSubjectToTravelRule: boolean;
    kycStatus: KycStatus;
    signature: string;
    signatureNonce: string;
    signatureTimestamp: number;
    receiverIdentifier: string;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | undefined;
}, {
    isSubjectToTravelRule: boolean;
    kycStatus: KycStatus;
    signature: string;
    signatureNonce: string;
    signatureTimestamp: number;
    receiverIdentifier: string;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | null | undefined;
}>;
type LnurlComplianceResponse = z.infer<typeof LnurlpComplianceResponseSchema>;
declare const LnurlpResponseSchema: z.ZodObject<{
    tag: z.ZodString;
    callback: z.ZodString;
    minSendable: z.ZodNumber;
    maxSendable: z.ZodNumber;
    metadata: z.ZodString;
    currencies: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<({
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        convertible: {
            min: number;
            max: number;
        };
    } | {
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        minSendable: number;
        maxSendable: number;
    })[], z.ZodTypeDef, ({
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        convertible: {
            min: number;
            max: number;
        };
    } | {
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        minSendable: number;
        maxSendable: number;
    })[]>>, ({
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        convertible: {
            min: number;
            max: number;
        };
    } | {
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        minSendable: number;
        maxSendable: number;
    })[] | undefined, ({
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        convertible: {
            min: number;
            max: number;
        };
    } | {
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        minSendable: number;
        maxSendable: number;
    })[] | null>>;
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        isSubjectToTravelRule: boolean;
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        receiverIdentifier: string;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
    }, z.ZodTypeDef, {
        isSubjectToTravelRule: boolean;
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        receiverIdentifier: string;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
    }>>, {
        isSubjectToTravelRule: boolean;
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        receiverIdentifier: string;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
    } | undefined, {
        isSubjectToTravelRule: boolean;
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        receiverIdentifier: string;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
    } | null>>;
    umaVersion: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    commentAllowed: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<number, z.ZodTypeDef, number>>, number | undefined, number | null>>;
    nostrPubkey: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    allowsNostr: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    settlementOptions: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        settlementLayer: string;
        assets: {
            identifier: string;
            multipliers: Record<string, number>;
        }[];
    }[], z.ZodTypeDef, {
        settlementLayer: string;
        assets: {
            identifier: string;
            multipliers: Record<string, number>;
        }[];
    }[]>>, {
        settlementLayer: string;
        assets: {
            identifier: string;
            multipliers: Record<string, number>;
        }[];
    }[] | undefined, {
        settlementLayer: string;
        assets: {
            identifier: string;
            multipliers: Record<string, number>;
        }[];
    }[] | null>>;
}, "strip", z.ZodTypeAny, {
    minSendable: number;
    maxSendable: number;
    callback: string;
    tag: string;
    metadata: string;
    compliance?: {
        isSubjectToTravelRule: boolean;
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        receiverIdentifier: string;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
    } | undefined;
    umaVersion?: string | undefined;
    currencies?: ({
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        convertible: {
            min: number;
            max: number;
        };
    } | {
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        minSendable: number;
        maxSendable: number;
    })[] | undefined;
    payerData?: Record<string, {
        mandatory: boolean;
    }> | undefined;
    commentAllowed?: number | undefined;
    nostrPubkey?: string | undefined;
    allowsNostr?: boolean | undefined;
    settlementOptions?: {
        settlementLayer: string;
        assets: {
            identifier: string;
            multipliers: Record<string, number>;
        }[];
    }[] | undefined;
}, {
    minSendable: number;
    maxSendable: number;
    callback: string;
    tag: string;
    metadata: string;
    compliance?: {
        isSubjectToTravelRule: boolean;
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        receiverIdentifier: string;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
    } | null | undefined;
    umaVersion?: string | null | undefined;
    currencies?: ({
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        convertible: {
            min: number;
            max: number;
        };
    } | {
        symbol: string;
        name: string;
        code: string;
        multiplier: number;
        decimals: number;
        minSendable: number;
        maxSendable: number;
    })[] | null | undefined;
    payerData?: Record<string, {
        mandatory: boolean;
    }> | null | undefined;
    commentAllowed?: number | null | undefined;
    nostrPubkey?: string | null | undefined;
    allowsNostr?: boolean | null | undefined;
    settlementOptions?: {
        settlementLayer: string;
        assets: {
            identifier: string;
            multipliers: Record<string, number>;
        }[];
    }[] | null | undefined;
}>;

declare const CompliancePayeeDataSchema: z.ZodObject<{
    /** nodePubKey is the public key of the receiver's node if known. */
    nodePubKey: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /** utxos is a list of UTXOs of channels over which the receiver will likely receive the payment. */
    utxos: z.ZodArray<z.ZodString, "many">;
    /** utxoCallback is the URL that the sender VASP will call to send UTXOs of the channel that the sender used to send the payment once it completes. */
    utxoCallback: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Signature is the base64-encoded signature of sha256(SenderAddress|ReceiverAddress|Nonce|Timestamp).
     *
     * Note: This field is optional for UMA v0.X backwards-compatibility. It is required for UMA v1.X.
     */
    signature: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Nonce is a random string that is used to prevent replay attacks.
     *
     * Note: This field is optional for UMA v0.X backwards-compatibility. It is required for UMA v1.X.
     */
    signatureNonce: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Timestamp is the unix timestamp (seconds since epoch) of when the request was sent. Used in the signature.
     *
     * Note: This field is optional for UMA v0.X backwards-compatibility. It is required for UMA v1.X.
     */
    signatureTimestamp: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<number, z.ZodTypeDef, number>>, number | undefined, number | null>>;
    /** BackingSignatures is a list of backing signatures from VASPs that can attest to the authenticity of the message. */
    backingSignatures: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        signature: string;
        domain: string;
    }[], z.ZodTypeDef, {
        signature: string;
        domain: string;
    }[]>>, {
        signature: string;
        domain: string;
    }[] | undefined, {
        signature: string;
        domain: string;
    }[] | null>>;
}, "strip", z.ZodTypeAny, {
    utxos: string[];
    signature?: string | undefined;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | undefined;
    signatureNonce?: string | undefined;
    signatureTimestamp?: number | undefined;
    nodePubKey?: string | undefined;
    utxoCallback?: string | undefined;
}, {
    utxos: string[];
    signature?: string | null | undefined;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | null | undefined;
    signatureNonce?: string | null | undefined;
    signatureTimestamp?: number | null | undefined;
    nodePubKey?: string | null | undefined;
    utxoCallback?: string | null | undefined;
}>;
type CompliancePayeeData = z.infer<typeof CompliancePayeeDataSchema>;
declare const PayeeDataSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }, z.ZodTypeDef, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }>>, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }, z.ZodTypeDef, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }>>, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }, z.ZodTypeDef, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }>>, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined, {
        utxos: string[];
        signature?: string | null | undefined;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        signatureNonce?: string | null | undefined;
        signatureTimestamp?: number | null | undefined;
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null>>;
}, z.ZodTypeAny, "passthrough">>;
type PayeeData = z.infer<typeof PayeeDataSchema>;

declare const CompliancePayerDataSchema: z.ZodObject<{
    /** Utxos is the list of UTXOs of the sender's channels that might be used to fund the payment. */
    utxos: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string[], z.ZodTypeDef, string[]>>, string[] | undefined, string[] | null>>;
    /** NodePubKey is the public key of the sender's node if known. */
    nodePubKey: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /** KycStatus indicates whether VASP1 has KYC information about the sender. */
    kycStatus: z.ZodNativeEnum<typeof KycStatus>;
    /** EncryptedTravelRuleInfo is the travel rule information of the sender. This is encrypted with the receiver's public encryption key. */
    encryptedTravelRuleInfo: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An optional standardized format of the travel rule information (e.g. IVMS). Null indicates raw json or a custom format.
     * This field is formatted as <standardized format>@<version> (e.g. ivms@101.2023). Version is optional.
     */
    travelRuleFormat: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /** Signature is the base64-encoded signature of sha256(ReceiverAddress|Nonce|Timestamp). */
    signature: z.ZodString;
    signatureNonce: z.ZodString;
    signatureTimestamp: z.ZodNumber;
    /** UtxoCallback is the URL that the receiver will call to send UTXOs of the channel that the receiver used to receive the payment once it completes. */
    utxoCallback: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /** BackingSignatures is a list of backing signatures from VASPs that can attest to the authenticity of the message. */
    backingSignatures: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        signature: string;
        domain: string;
    }[], z.ZodTypeDef, {
        signature: string;
        domain: string;
    }[]>>, {
        signature: string;
        domain: string;
    }[] | undefined, {
        signature: string;
        domain: string;
    }[] | null>>;
}, "strip", z.ZodTypeAny, {
    kycStatus: KycStatus;
    signature: string;
    signatureNonce: string;
    signatureTimestamp: number;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | undefined;
    nodePubKey?: string | undefined;
    utxos?: string[] | undefined;
    utxoCallback?: string | undefined;
    encryptedTravelRuleInfo?: string | undefined;
    travelRuleFormat?: string | undefined;
}, {
    kycStatus: KycStatus;
    signature: string;
    signatureNonce: string;
    signatureTimestamp: number;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | null | undefined;
    nodePubKey?: string | null | undefined;
    utxos?: string[] | null | undefined;
    utxoCallback?: string | null | undefined;
    encryptedTravelRuleInfo?: string | null | undefined;
    travelRuleFormat?: string | null | undefined;
}>;
type CompliancePayerData = z.infer<typeof CompliancePayerDataSchema>;
declare const PayerDataSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    }, z.ZodTypeDef, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    }>>, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    } | undefined, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    } | null>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    }, z.ZodTypeDef, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    }>>, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    } | undefined, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    } | null>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    }, z.ZodTypeDef, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    }>>, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    } | undefined, {
        kycStatus: KycStatus;
        signature: string;
        signatureNonce: string;
        signatureTimestamp: number;
        backingSignatures?: {
            signature: string;
            domain: string;
        }[] | null | undefined;
        nodePubKey?: string | null | undefined;
        utxos?: string[] | null | undefined;
        utxoCallback?: string | null | undefined;
        encryptedTravelRuleInfo?: string | null | undefined;
        travelRuleFormat?: string | null | undefined;
    } | null>>;
}, z.ZodTypeAny, "passthrough">>;
type PayerData = z.infer<typeof PayerDataSchema>;

declare class PayReqResponse {
    /** The BOLT11 invoice that the sender will pay. */
    readonly pr: string;
    /**
     * The data about the receiver that the sending VASP requested in the payreq request.
     * Required for UMA.
     */
    readonly payeeData: PayeeData | undefined;
    /**
     * Information about the payment that the receiver will receive. Includes
     * Final currency-related information for the payment. Required for UMA.
     */
    readonly converted: PayReqResponsePaymentInfo | undefined;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    readonly disposable: boolean | undefined;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    readonly successAction: Record<string, string> | undefined;
    /**
     * The major version of the UMA protocol that this currency adheres to. This is not
     * serialized to JSON.
     */
    readonly umaMajorVersion: number;
    /**
     * Usually just an empty list from legacy LNURL, which was replaced by route
     * hints in the BOLT11 invoice.
     */
    readonly routes: Route[];
    constructor(
    /** The BOLT11 invoice that the sender will pay. */
    pr: string, 
    /**
     * The data about the receiver that the sending VASP requested in the payreq request.
     * Required for UMA.
     */
    payeeData: PayeeData | undefined, 
    /**
     * Information about the payment that the receiver will receive. Includes
     * Final currency-related information for the payment. Required for UMA.
     */
    converted: PayReqResponsePaymentInfo | undefined, 
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: boolean | undefined, 
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: Record<string, string> | undefined, 
    /**
     * The major version of the UMA protocol that this currency adheres to. This is not
     * serialized to JSON.
     */
    umaMajorVersion: number, 
    /**
     * Usually just an empty list from legacy LNURL, which was replaced by route
     * hints in the BOLT11 invoice.
     */
    routes?: Route[]);
    isUma(): this is PayReqResponse & {
        payeeData: PayeeData;
        converted: PayReqResponsePaymentInfo;
    };
    toJsonString(): string;
    toJSON(): string;
    toJsonSchemaObject(): z.infer<typeof V0PayReqResponseSchema> | z.infer<typeof V1PayReqResponseSchema>;
    /**
     * Appends a backing signature to the PayReqResponse.
     *
     * @param signingPrivateKey The private key used to sign the payload
     * @param domain The domain of the VASP that is signing the payload
     * @param payerIdentifier The identifier of the payer
     * @param payeeIdentifier The identifier of the payee
     * @returns A new PayReqResponse with the additional backing signature
     */
    appendBackingSignature(signingPrivateKey: Uint8Array, domain: string, payerIdentifier: string, payeeIdentifier: string): Promise<PayReqResponse>;
    static fromJson(json: string): PayReqResponse;
    static parse(data: unknown): PayReqResponse;
    static fromSchema(schema: z.infer<typeof PayReqResponseSchema>): PayReqResponse;
    signablePayload(payerIdentifier: string, payeeIdentifier: string): string;
}
declare const RouteSchema: z.ZodObject<{
    pubkey: z.ZodString;
    path: z.ZodArray<z.ZodObject<{
        pubkey: z.ZodString;
        fee: z.ZodNumber;
        msatoshi: z.ZodNumber;
        channel: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        fee: number;
        pubkey: string;
        msatoshi: number;
        channel: string;
    }, {
        fee: number;
        pubkey: string;
        msatoshi: number;
        channel: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    path: {
        fee: number;
        pubkey: string;
        msatoshi: number;
        channel: string;
    }[];
    pubkey: string;
}, {
    path: {
        fee: number;
        pubkey: string;
        msatoshi: number;
        channel: string;
    }[];
    pubkey: string;
}>;
type Route = z.infer<typeof RouteSchema>;
declare const PayReqResponsePaymentInfoSchema: z.ZodEffects<z.ZodUnion<[z.ZodObject<{
    /** currencyCode is the ISO 3-digit currency code that the receiver will receive for this payment. */
    currencyCode: z.ZodString;
    /**
     * Number of digits after the decimal point for the receiving currency. For example, in USD, by
     * convention, there are 2 digits for cents - $5.95. In this case, `decimals` would be 2. This should align with
     * the currency's `decimals` field in the LNURLP response. It is included here for convenience. See
     * [UMAD-04](https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md) for
     * details, edge cases, and examples.
     */
    decimals: z.ZodNumber;
    /** multiplier is the conversion rate. It is the number of millisatoshis that the receiver will receive for 1 unit of the specified currency. */
    multiplier: z.ZodNumber;
    /** exchangeFeesMillisatoshi is the fees charged (in millisats) by the receiving VASP for this transaction. This is separate from the Multiplier. */
    exchangeFeesMillisatoshi: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    exchangeFeesMillisatoshi: number;
}, {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    exchangeFeesMillisatoshi: number;
}>, z.ZodObject<{
    /**
     * The amount that the receiver will receive in the receiving currency not including fees. The amount is specified
     * in the smallest unit of the currency (eg. cents for USD).
     */
    amount: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<number, z.ZodTypeDef, number>>, number | undefined, number | null>>;
    /** currencyCode is the ISO 3-digit currency code that the receiver will receive for this payment. */
    currencyCode: z.ZodString;
    /**
     * Number of digits after the decimal point for the receiving currency. For example, in USD, by
     * convention, there are 2 digits for cents - $5.95. In this case, `decimals` would be 2. This should align with
     * the currency's `decimals` field in the LNURLP response. It is included here for convenience. See
     * [UMAD-04](https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md) for
     * details, edge cases, and examples.
     */
    decimals: z.ZodNumber;
    /**
     * The conversion rate. In the default case (Lightning/BTC), it is the number of millisatoshis that the
     * receiver will receive for 1 unit of the specified currency (eg: cents in USD). For other settlement
     * layers, this is the number of the smallest unit of the settlement asset that the receiver will
     * receive for 1 unit of the specified currency.
     */
    multiplier: z.ZodNumber;
    /**
     * The fees charged by the receiving VASP for this transaction. In the default case (Lightning/BTC),
     * this is in millisatoshis. For other settlement layers, this is in the smallest unit of the
     * settlement asset. This is separate from the `multiplier`.
     */
    fee: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    fee: number;
    amount?: number | undefined;
}, {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    fee: number;
    amount?: number | null | undefined;
}>]>, {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    fee: number;
    amount?: number | undefined;
}, {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    exchangeFeesMillisatoshi: number;
} | {
    multiplier: number;
    decimals: number;
    currencyCode: string;
    fee: number;
    amount?: number | null | undefined;
}>;
type PayReqResponsePaymentInfo = z.infer<typeof PayReqResponsePaymentInfoSchema>;
declare const V0PayReqResponseComplianceSchema: z.ZodObject<{
    /** nodePubKey is the public key of the receiver's node if known. */
    nodePubKey: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /** utxos is a list of UTXOs of channels over which the receiver will likely receive the payment. */
    utxos: z.ZodArray<z.ZodString, "many">;
    /** utxoCallback is the URL that the sender VASP will call to send UTXOs of the channel that the sender used to send the payment once it completes. */
    utxoCallback: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
}, "strip", z.ZodTypeAny, {
    utxos: string[];
    nodePubKey?: string | undefined;
    utxoCallback?: string | undefined;
}, {
    utxos: string[];
    nodePubKey?: string | null | undefined;
    utxoCallback?: string | null | undefined;
}>;
declare const PayReqResponseComplianceSchema: z.ZodUnion<[z.ZodObject<{
    /** nodePubKey is the public key of the receiver's node if known. */
    nodePubKey: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /** utxos is a list of UTXOs of channels over which the receiver will likely receive the payment. */
    utxos: z.ZodArray<z.ZodString, "many">;
    /** utxoCallback is the URL that the sender VASP will call to send UTXOs of the channel that the sender used to send the payment once it completes. */
    utxoCallback: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
}, "strip", z.ZodTypeAny, {
    utxos: string[];
    nodePubKey?: string | undefined;
    utxoCallback?: string | undefined;
}, {
    utxos: string[];
    nodePubKey?: string | null | undefined;
    utxoCallback?: string | null | undefined;
}>, z.ZodObject<{
    nodePubKey: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    utxos: z.ZodArray<z.ZodString, "many">;
    utxoCallback: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    signature: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    signatureNonce: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    signatureTimestamp: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<number, z.ZodTypeDef, number>>, number | undefined, number | null>>;
    backingSignatures: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        signature: string;
        domain: string;
    }[], z.ZodTypeDef, {
        signature: string;
        domain: string;
    }[]>>, {
        signature: string;
        domain: string;
    }[] | undefined, {
        signature: string;
        domain: string;
    }[] | null>>;
}, "strip", z.ZodTypeAny, {
    utxos: string[];
    signature?: string | undefined;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | undefined;
    signatureNonce?: string | undefined;
    signatureTimestamp?: number | undefined;
    nodePubKey?: string | undefined;
    utxoCallback?: string | undefined;
}, {
    utxos: string[];
    signature?: string | null | undefined;
    backingSignatures?: {
        signature: string;
        domain: string;
    }[] | null | undefined;
    signatureNonce?: string | null | undefined;
    signatureTimestamp?: number | null | undefined;
    nodePubKey?: string | null | undefined;
    utxoCallback?: string | null | undefined;
}>]>;
declare const V1PayReqResponseSchema: z.ZodEffects<z.ZodObject<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">>, z.objectOutputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">>;
declare const V0PayReqResponseSchema: z.ZodObject<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    paymentInfo: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }, z.ZodTypeDef, {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }>>, {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined, {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null>>;
}>, "strip", z.ZodTypeAny, {
    pr: string;
    compliance?: {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined;
    routes?: {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined;
    payeeData?: NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined;
    disposable?: boolean | undefined;
    successAction?: Record<string, string> | undefined;
    paymentInfo?: {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | undefined;
}, {
    pr: string;
    compliance?: {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null | undefined;
    routes?: {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null | undefined;
    payeeData?: z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null | undefined;
    disposable?: boolean | null | undefined;
    successAction?: Record<string, string> | null | undefined;
    paymentInfo?: {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | null | undefined;
}>;
declare const PayReqResponseSchema: z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodObject<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">>, z.objectOutputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    paymentInfo: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | null>>;
    compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }, z.ZodTypeDef, {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    }>>, {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined, {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null>>;
}>, "strip", z.ZodTypeAny, {
    pr: string;
    compliance?: {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | undefined;
    routes?: {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined;
    payeeData?: NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined;
    disposable?: boolean | undefined;
    successAction?: Record<string, string> | undefined;
    paymentInfo?: {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | undefined;
}, {
    pr: string;
    compliance?: {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null | undefined;
    routes?: {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null | undefined;
    payeeData?: z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null | undefined;
    disposable?: boolean | null | undefined;
    successAction?: Record<string, string> | null | undefined;
    paymentInfo?: {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | null | undefined;
}>]>, {
    pr: string;
    routes?: {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined;
    payeeData?: NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined;
    disposable?: boolean | undefined;
    successAction?: Record<string, string> | undefined;
    converted?: {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined;
} & {
    [k: string]: unknown;
} & {
    umaMajorVersion: number;
}, {
    pr: string;
    compliance?: {
        utxos: string[];
        nodePubKey?: string | null | undefined;
        utxoCallback?: string | null | undefined;
    } | null | undefined;
    routes?: {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null | undefined;
    payeeData?: z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null | undefined;
    disposable?: boolean | null | undefined;
    successAction?: Record<string, string> | null | undefined;
    paymentInfo?: {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        exchangeFeesMillisatoshi: number;
    } | null | undefined;
} | z.objectInputType<z.objectUtil.extendShape<{
    /** The BOLT11 invoice that the sender will pay. */
    pr: z.ZodString;
    /** routes is usually just an empty list from legacy LNURL, which was replaced by route hints in the BOLT11 invoice. */
    routes: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[], z.ZodTypeDef, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[]>>, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | undefined, {
        path: {
            fee: number;
            pubkey: string;
            msatoshi: number;
            channel: string;
        }[];
        pubkey: string;
    }[] | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }, z.ZodTypeDef, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        }>>, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | undefined, {
            utxos: string[];
            signature?: string | null | undefined;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            signatureNonce?: string | null | undefined;
            signatureTimestamp?: number | null | undefined;
            nodePubKey?: string | null | undefined;
            utxoCallback?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<boolean, z.ZodTypeDef, boolean>>, boolean | undefined, boolean | null>>;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, string>, z.ZodTypeDef, Record<string, string>>>, Record<string, string> | undefined, Record<string, string> | null>>;
}, {
    converted: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }, z.ZodTypeDef, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    }>>, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | undefined, {
        multiplier: number;
        decimals: number;
        currencyCode: string;
        fee: number;
        amount?: number | null | undefined;
    } | null>>;
}>, z.ZodTypeAny, "passthrough">>;

declare const V1PayRequestSchema: z.ZodEffects<z.ZodObject<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">>;
declare const V0PayRequestSchema: z.ZodObject<{
    currency: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    amount: z.ZodNumber;
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
}, "strip", z.ZodTypeAny, {
    amount: number;
    payerData?: NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined;
    payeeData?: Record<string, {
        mandatory: boolean;
    }> | undefined;
    comment?: string | undefined;
    currency?: string | undefined;
}, {
    amount: number;
    payerData?: z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null | undefined;
    payeeData?: Record<string, {
        mandatory: boolean;
    }> | null | undefined;
    comment?: string | null | undefined;
    currency?: string | null | undefined;
}>;
declare const PayRequestSchema: z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
    currency: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    amount: z.ZodNumber;
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
}, "strip", z.ZodTypeAny, {
    amount: number;
    payerData?: NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined;
    payeeData?: Record<string, {
        mandatory: boolean;
    }> | undefined;
    comment?: string | undefined;
    currency?: string | undefined;
}, {
    amount: number;
    payerData?: z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null | undefined;
    payeeData?: Record<string, {
        mandatory: boolean;
    }> | null | undefined;
    comment?: string | null | undefined;
    currency?: string | null | undefined;
}>]>, {
    amount: string;
    invoiceUUID?: string | undefined;
    payerData?: NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined;
    payeeData?: Record<string, {
        mandatory: boolean;
    }> | undefined;
    convert?: string | undefined;
    comment?: string | undefined;
    settlement?: {
        layer: string;
        assetIdentifier: string;
    } | undefined;
} & {
    [k: string]: unknown;
} & {
    umaMajorVersion: number;
}, z.objectInputType<{
    /** The 3-character currency code that the receiver will receive for this payment. */
    convert: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * An amount (int64) followed optionally by a "." and the sending currency code. For example: "100.USD" would send
     * an amount equivalent to $1 USD. Note that the amount is specified in the smallest unit of the specified
     * currency (eg. cents for USD). Omitting the currency code will default to specifying the amount in millisats.
     */
    amount: z.ZodString;
    /** The data that the sender will send to the receiver to identify themselves. See LUD-18. */
    payerData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">, z.ZodTypeDef, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">>>, NonNullable<z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough">> | undefined, z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null>>;
    /** The fields requested about the payee by the sending vasp, if any. */
    payeeData: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<Record<string, {
        mandatory: boolean;
    }>, z.ZodTypeDef, Record<string, {
        mandatory: boolean;
    }>>>, Record<string, {
        mandatory: boolean;
    }> | undefined, Record<string, {
        mandatory: boolean;
    }> | null>>;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * InvoiceUUID is the invoice UUID that the sender is paying.
     * This only exists in the v1 pay request since the v0 SDK won't support invoices.
     */
    invoiceUUID: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
        layer: string;
        assetIdentifier: string;
    }, z.ZodTypeDef, {
        layer: string;
        assetIdentifier: string;
    }>>, {
        layer: string;
        assetIdentifier: string;
    } | undefined, {
        layer: string;
        assetIdentifier: string;
    } | null>>;
}, z.ZodTypeAny, "passthrough"> | {
    amount: number;
    payerData?: z.objectInputType<{
        name: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        email: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        identifier: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<string, z.ZodTypeDef, string>>, string | undefined, string | null>>;
        compliance: z.ZodOptional<z.ZodEffects<z.ZodNullable<z.ZodType<{
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }, z.ZodTypeDef, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        }>>, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | undefined, {
            kycStatus: KycStatus;
            signature: string;
            signatureNonce: string;
            signatureTimestamp: number;
            backingSignatures?: {
                signature: string;
                domain: string;
            }[] | null | undefined;
            nodePubKey?: string | null | undefined;
            utxos?: string[] | null | undefined;
            utxoCallback?: string | null | undefined;
            encryptedTravelRuleInfo?: string | null | undefined;
            travelRuleFormat?: string | null | undefined;
        } | null>>;
    }, z.ZodTypeAny, "passthrough"> | null | undefined;
    payeeData?: Record<string, {
        mandatory: boolean;
    }> | null | undefined;
    comment?: string | null | undefined;
    currency?: string | null | undefined;
}>;
/**
 * A class which wraps the `PayRequestSchema` and provides a more convenient interface for
 * creating and parsing PayRequests.
 *
 * NOTE: The `fromJson` and `toJsonString` methods are used to convert to and from JSON strings.
 * This is necessary because `JSON.stringify` will not include the correct field names.
 */
declare class PayRequest {
    /**
     * The amount of the payment in the currency specified by `currency_code`. This amount is
     * in the smallest unit of the specified currency (e.g. cents for USD).
     */
    readonly amount: number;
    /**
     * The 3-character currency code that the receiver will receive for this payment.
     */
    readonly receivingCurrencyCode: string | undefined;
    /**
     * The currency code of the `amount` field. `None` indicates that `amount` is in the smallest
     * unit of the settlement asset. For lightning, this is millisatoshis as in LNURL without LUD-21.
     * If this is not `None`, then `amount` is in the smallest unit of the specified currency
     * (e.g. cents for USD). This currency code can be any currency which the receiver can quote.
     * However, there are two most common scenarios for UMA:
     *
     * 1. If the sender wants the receiver wants to receive a specific amount in their receiving
     * currency, then this field should be the same as `receiving_currency_code`. This is useful
     * for cases where the sender wants to ensure that the receiver receives a specific amount
     * in that destination currency, regardless of the exchange rate, for example, when paying
     * for some goods or services in a foreign currency.
     *
     * 2. If the sender has a specific amount in their own currency that they would like to send,
     * then this field should be left as `None` to indicate that the amount is in the smallest
     * unit of the settlement asset (ie. msats by default).
     * This will lock the sent amount on the sender side, and the receiver will receive the
     * equivalent amount in their receiving currency. NOTE: In this scenario, the sending VASP
     * *should not* pass the sending currency code here, as it is not relevant to the receiver.
     * Rather, by specifying an invoice amount in the settlement asset (for example, msats for
     * lightning), the sending VASP can ensure that their user will be sending a fixed amount,
     * regardless of the exchange rate on the receiving side.
     */
    readonly sendingAmountCurrencyCode: string | undefined;
    /**
     * The major version of the UMA protocol that this currency adheres to. This is not serialized to JSON.
     */
    readonly umaMajorVersion: number;
    /**
     * The data about the payer that the sending VASP must provide in order to send a payment.
     * This was requested by the receiver in the lnulp response. See LUD-18.
     */
    readonly payerData?: z.infer<typeof PayerDataSchema> | undefined;
    /**
     * The data about the receiver that the sending VASP would like to know from the receiver.
     * See LUD-22.
     */
    readonly requestedPayeeData?: CounterPartyDataOptions | undefined;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    readonly comment?: string | undefined;
    /**
     * Associated UMA Invoice UUID
     */
    readonly invoiceUUID?: string | undefined;
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    readonly settlement?: SettlementInfo | undefined;
    constructor(
    /**
     * The amount of the payment in the currency specified by `currency_code`. This amount is
     * in the smallest unit of the specified currency (e.g. cents for USD).
     */
    amount: number, 
    /**
     * The 3-character currency code that the receiver will receive for this payment.
     */
    receivingCurrencyCode: string | undefined, 
    /**
     * The currency code of the `amount` field. `None` indicates that `amount` is in the smallest
     * unit of the settlement asset. For lightning, this is millisatoshis as in LNURL without LUD-21.
     * If this is not `None`, then `amount` is in the smallest unit of the specified currency
     * (e.g. cents for USD). This currency code can be any currency which the receiver can quote.
     * However, there are two most common scenarios for UMA:
     *
     * 1. If the sender wants the receiver wants to receive a specific amount in their receiving
     * currency, then this field should be the same as `receiving_currency_code`. This is useful
     * for cases where the sender wants to ensure that the receiver receives a specific amount
     * in that destination currency, regardless of the exchange rate, for example, when paying
     * for some goods or services in a foreign currency.
     *
     * 2. If the sender has a specific amount in their own currency that they would like to send,
     * then this field should be left as `None` to indicate that the amount is in the smallest
     * unit of the settlement asset (ie. msats by default).
     * This will lock the sent amount on the sender side, and the receiver will receive the
     * equivalent amount in their receiving currency. NOTE: In this scenario, the sending VASP
     * *should not* pass the sending currency code here, as it is not relevant to the receiver.
     * Rather, by specifying an invoice amount in the settlement asset (for example, msats for
     * lightning), the sending VASP can ensure that their user will be sending a fixed amount,
     * regardless of the exchange rate on the receiving side.
     */
    sendingAmountCurrencyCode: string | undefined, 
    /**
     * The major version of the UMA protocol that this currency adheres to. This is not serialized to JSON.
     */
    umaMajorVersion: number, 
    /**
     * The data about the payer that the sending VASP must provide in order to send a payment.
     * This was requested by the receiver in the lnulp response. See LUD-18.
     */
    payerData?: z.infer<typeof PayerDataSchema> | undefined, 
    /**
     * The data about the receiver that the sending VASP would like to know from the receiver.
     * See LUD-22.
     */
    requestedPayeeData?: CounterPartyDataOptions | undefined, 
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment?: string | undefined, 
    /**
     * Associated UMA Invoice UUID
     */
    invoiceUUID?: string | undefined, 
    /**
     * Settlement information including the layer and asset chosen by the sender.
     * Must be one of the options provided by the receiver in the lnurlp response.
     * If not specified, defaults to Lightning with BTC.
     */
    settlement?: SettlementInfo | undefined);
    /**
     * @returns true if this PayRequest is for UMA. False if for regular lnurl.
     */
    isUma(): this is {
        payerData: PayerData;
        receivingCurrencyCode: string;
    };
    toJsonSchemaObject(): z.infer<typeof V0PayRequestSchema> | z.infer<typeof V1PayRequestSchema>;
    /**
     * NOTE: This MUST be used when sending the PayRequest to the receiver rather than
     * `JSON.stringify` because the latter will not include the correct field names.
     * @returns a JSON string representation of the PayRequest.
     */
    toJsonString(): string;
    toJSON(): string;
    signablePayload(): string;
    /**
     * Appends a backing signature to the PayRequest.
     *
     * @param signingPrivateKey The private key used to sign the payload
     * @param domain The domain of the VASP that is signing the payload
     * @returns A new PayRequest with the additional backing signature
     */
    appendBackingSignature(signingPrivateKey: Uint8Array, domain: string): Promise<PayRequest>;
    static fromSchema(schema: z.infer<typeof PayRequestSchema>): PayRequest;
    static parse(data: unknown): PayRequest;
    static fromJson(jsonStr: string): PayRequest;
    /**
     * Parse a PayRequest from a URLSearchParams object. Should only be used for
     * non-UMA pay requests because UMA uses POST requests for payreq.
     */
    static fromUrlSearchParams(params: URLSearchParams): PayRequest;
}

/** UtxoWithAmount is a pair of utxo and amount transferred over that corresponding channel. It can be used to register payment for KYT. */
declare const UtxoWithAmountSchema: z.ZodObject<{
    /** Utxo The utxo of the channel over which the payment went through in the format of <transaction_hash>:<output_index>. */
    utxo: z.ZodString;
    /** Amount The amount of funds transferred in the payment in mSats. */
    amountMsats: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    utxo: string;
    amountMsats: number;
}, {
    utxo: string;
    amountMsats: number;
}>;
type UtxoWithAmount = z.infer<typeof UtxoWithAmountSchema>;
/** PostTransactionCallback is sent between VASPs after the payment is complete. */
declare const PostTransactionCallbackSchema: z.ZodObject<{
    /** Utxos is a list of utxo/amounts corresponding to the VASPs channels. */
    utxos: z.ZodArray<z.ZodObject<{
        /** Utxo The utxo of the channel over which the payment went through in the format of <transaction_hash>:<output_index>. */
        utxo: z.ZodString;
        /** Amount The amount of funds transferred in the payment in mSats. */
        amountMsats: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        utxo: string;
        amountMsats: number;
    }, {
        utxo: string;
        amountMsats: number;
    }>, "many">;
    /** VaspDomain is the domain of the VASP that is sending the callback. It will be used by the VASP to fetch the public keys of its counterparty. */
    vaspDomain: z.ZodString;
    /** Signature is the base64-encoded signature of sha256(Nonce|Timestamp). */
    signature: z.ZodString;
    /** Nonce is a random string that is used to prevent replay attacks. */
    signatureNonce: z.ZodString;
    /** Timestamp is the unix timestamp of when the request was sent. Used in the signature. */
    signatureTimestamp: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    signature: string;
    vaspDomain: string;
    signatureNonce: string;
    signatureTimestamp: number;
    utxos: {
        utxo: string;
        amountMsats: number;
    }[];
}, {
    signature: string;
    vaspDomain: string;
    signatureNonce: string;
    signatureTimestamp: number;
    utxos: {
        utxo: string;
        amountMsats: number;
    }[];
}>;
type PostTransactionCallback = z.infer<typeof PostTransactionCallbackSchema>;
declare function parsePostTransactionCallback(jsonStr: string): PostTransactionCallback;
declare function getSignablePostTransactionCallback(c: PostTransactionCallback): string;

type X509Certificate = crypto.X509Certificate;
/** PubKeyResponse is sent from a VASP to another VASP to provide its public keys. It is the response to GET requests at `/.well-known/lnurlpubkey`. */
declare class PubKeyResponse {
    /**
     * SigningCertChain is a PEM encoded X.509 certificate chain. Certificates are ordered from
     * leaf to root. The signing public key can be extracted from the leaf certificate and is used
     * to verify signatures from a VASP.
     */
    readonly signingCertChain?: X509Certificate[] | undefined;
    /**
     * EncryptionCertChain is a PEM encoded X.509 certificate chain. Certificates are ordered from
     * leaf to root. The encryption public key can be extracted from the leaf certificate and is used
     * to verify signatures from a VASP.
     */
    readonly encryptionCertChain?: X509Certificate[] | undefined;
    /** SigningPubKey is used to verify signatures from a VASP. */
    readonly signingPubKey?: string | undefined;
    /** EncryptionPubKey is used to encrypt TR info sent to a VASP. */
    readonly encryptionPubKey?: string | undefined;
    /** [Optional] Seconds since epoch at which these pub keys must be refreshed. They can be safely cached until this expiration (or forever if null). */
    readonly expirationTimestamp?: number | undefined;
    constructor(
    /**
     * SigningCertChain is a PEM encoded X.509 certificate chain. Certificates are ordered from
     * leaf to root. The signing public key can be extracted from the leaf certificate and is used
     * to verify signatures from a VASP.
     */
    signingCertChain?: X509Certificate[] | undefined, 
    /**
     * EncryptionCertChain is a PEM encoded X.509 certificate chain. Certificates are ordered from
     * leaf to root. The encryption public key can be extracted from the leaf certificate and is used
     * to verify signatures from a VASP.
     */
    encryptionCertChain?: X509Certificate[] | undefined, 
    /** SigningPubKey is used to verify signatures from a VASP. */
    signingPubKey?: string | undefined, 
    /** EncryptionPubKey is used to encrypt TR info sent to a VASP. */
    encryptionPubKey?: string | undefined, 
    /** [Optional] Seconds since epoch at which these pub keys must be refreshed. They can be safely cached until this expiration (or forever if null). */
    expirationTimestamp?: number | undefined);
    getSigningPubKey(): Uint8Array;
    getEncryptionPubKey(): Uint8Array;
    toJsonString(): string;
    toJSON(): string;
    static fromJson(jsonStr: string): PubKeyResponse;
}

interface PublicKeyCache {
    fetchPublicKeyForVasp(vaspDomain: string): PubKeyResponse | undefined;
    addPublicKeyForVasp(vaspDomain: string, pubKey: PubKeyResponse): void;
    removePublicKeyForVasp(vaspDomain: string): void;
    clear(): void;
}
declare class InMemoryPublicKeyCache {
    cache: Map<string, PubKeyResponse>;
    constructor();
    fetchPublicKeyForVasp(vaspDomain: string): PubKeyResponse | undefined;
    addPublicKeyForVasp(vaspDomain: string, pubKey: PubKeyResponse): void;
    removePublicKeyForVasp(vaspDomain: string): void;
    clear(): void;
}

declare function signPayload(payload: string, privateKeyBytes: Uint8Array): Promise<string>;
declare function signBytePayload(payload: Uint8Array, privateKeyBytes: Uint8Array): Promise<Uint8Array>;
declare function uint8ArrayToHexString(uint8Array: Uint8Array): string;

interface UmaInvoiceCreator {
    /**
     * Creates an invoice with the given amount and encoded LNURL metadata.
     *
     * @param amountMsats The amount of the invoice in millisatoshis.
     * @param metadata The metadata that will be added to the invoice's metadata hash field.
     * @param receiverIdentifier The receiver's UMA address.
     * @return The encoded BOLT-11 invoice that should be returned to the sender for the given `PayRequest`.
     */
    createUmaInvoice: (amountMsats: number, metadata: string, receiverIdentifier: string | undefined) => Promise<string | undefined>;
    /**
     * Creates a payment request with settlement-agnostic parameters.
     *
     * @param amountUnits Amount in the smallest unit of the settlement asset.
     * @param metadata Metadata to include.
     * @param receiverIdentifier Receiver's UMA address.
     * @param settlementInfo Settlement info including the layer and asset chosen by the sender.
     * @return Payment request string.
     */
    createInvoiceForSettlementLayer?: (amountUnits: number, metadata: string, receiverIdentifier: string | undefined, settlementInfo: SettlementInfo | undefined) => Promise<string | undefined>;
}
declare function createInvoiceWithSettlement(creator: UmaInvoiceCreator, amountUnits: number, metadata: string, receiverIdentifier: string | undefined, settlementInfo: SettlementInfo | undefined): Promise<string | undefined>;

declare function parseLnurlpRequest(url: URL): LnurlpRequest;
declare function isUmaLnurlpQuery(url: URL): boolean;
declare function generateNonce(): string;
type FetchPublicKeyForVaspArgs = {
    cache: PublicKeyCache;
    vaspDomain: string;
};
/**
 * FetchPublicKeyForVasp fetches the public key for another VASP.
 * If the public key is not in the cache, it will be fetched from the VASP's domain.
 * The public key will be cached for future use.
 *
 * @param cache The PublicKeyCache cache to use. You can use the InMemoryPublicKeyCache class, or implement your own
 *     persistent cache with any storage type.
 * @param vaspDomain The domain of the VASP to fetch the public key for.
 * @returns
 */
declare function fetchPublicKeyForVasp({ cache, vaspDomain, }: FetchPublicKeyForVaspArgs): Promise<PubKeyResponse>;
type GetPubKeyResponseArgs = {
    /**
     * The chain of signing certificates in PEM format. The order of the certificates
     * should be from the leaf to the root. Used to verify signatures from a vasp.
     */
    signingCertChainPem: string;
    /**
     * The chain of encryption certificates in PEM format. The order of the certificates
     * should be from the leaf to the root. Used to encrypt TR info sent to a VASP.
     */
    encryptionCertChainPem: string;
    /** Seconds since epoch at which these pub keys must be refreshed. They can be safely cached until this expiration (or forever if null). */
    expirationTimestamp?: number;
};
/**
 * Creates a pub key response.
 */
declare function getPubKeyResponse({ signingCertChainPem, encryptionCertChainPem, expirationTimestamp, }: GetPubKeyResponseArgs): PubKeyResponse;
type GetSignedLnurlpRequestUrlArgs = {
    isSubjectToTravelRule: boolean;
    receiverAddress: string;
    senderVaspDomain: string;
    signingPrivateKey: Uint8Array;
    umaVersionOverride?: string | undefined;
};
/**
 * Creates a signed uma request URL.
 */
declare function getSignedLnurlpRequestUrl({ isSubjectToTravelRule, receiverAddress, senderVaspDomain, signingPrivateKey, umaVersionOverride, }: GetSignedLnurlpRequestUrlArgs): Promise<URL>;
declare function verifyUmaLnurlpQuerySignature(query: LnurlpRequest, otherVaspPubKeyResponse: PubKeyResponse, nonceValidator: NonceValidator): Promise<boolean>;
/**
 * Verifies the backing signatures on an UMA Lnurlp query. You may optionally call this function after
 * verifyUmaLnurlpQuerySignature to verify signatures from backing VASPs.
 *
 * @param query The signed query to verify
 * @param fetchPublicKeysForVasp Function to fetch public keys for a VASP domain
 * @returns true if all backing signatures are valid, false otherwise
 */
declare function verifyUmaLnurlpQueryBackingSignatures(query: LnurlpRequest, cache: PublicKeyCache): Promise<boolean>;
declare function verifyUmaInvoiceSignature(invoice: Invoice, publicKey: Uint8Array): Promise<boolean>;
declare function isValidUmaAddress(umaAddress: string): boolean;
declare function getVaspDomainFromUmaAddress(umaAddress: string): string;
type GetPayRequestArgs = {
    /** The public key of the receiver that will be used to encrypt the travel rule information. */
    receiverEncryptionPubKey: Uint8Array;
    /** The private key of the VASP that is sending the payment. This will be used to sign the request. */
    sendingVaspPrivateKey: Uint8Array;
    /** The code of the currency that the receiver will receive for this payment. */
    receivingCurrencyCode: string;
    /** The amount of the payment in the smallest unit of the specified currency (i.e. cents for USD). */
    amount: number;
    /**
     * Whether the amount field is specified in the smallest unit of the receiving currency (if
     * is_amount_in_receiving_currency is True), or in the smallest unit of the settlement asset (if false).
     */
    isAmountInReceivingCurrency: boolean;
    /** The identifier of the sender. For example, $alice@vasp1.com */
    payerIdentifier: string;
    /** The name of the sender (optional). Deprecated. Use payerData instead. */
    payerName?: string | undefined;
    /** The email of the sender (optional). Deprecated. Use payerData instead. */
    payerEmail?: string | undefined;
    /** The travel rule information. This will be encrypted before sending to the receiver. */
    trInfo?: string | undefined;
    /**
     * An optional standardized format of the travel rule information (e.g. IVMS). Null indicates raw json or a custom format.
     * This field is formatted as <standardized format>@<version> (e.g. ivms@101.2023). Version is optional.
     */
    travelRuleFormat?: string | undefined;
    /** Whether the sender is a KYC'd customer of the sending VASP. */
    payerKycStatus: KycStatus;
    /** The list of UTXOs of the sender's channels that might be used to fund the payment. */
    payerUtxos?: string[] | undefined;
    /**
     * If known, the public key of the sender's node. If supported by the receiving VASP's compliance provider,
     * this will be used to pre-screen the sender's UTXOs for compliance purposes.
     */
    payerNodePubKey?: string | undefined;
    /**
     * The URL that the receiver will call to send UTXOs of the channel that the receiver used to receive the
     * payment once it completes.
     */
    utxoCallback?: string | undefined;
    /**
     * The data requested by the sending VASP about the receiver.
     */
    requestedPayeeData?: CounterPartyDataOptions | undefined;
    /**
     * A comment that the sender would like to include with the payment. This can only be included
     * if the receiver included the `commentAllowed` field in the lnurlp response. The length of
     * the comment must be less than or equal to the value of `commentAllowed`.
     */
    comment?: string | undefined;
    /**
     * The major version of UMA used for this request. If non-UMA, this version is still relevant
     * for which LUD-21 spec to follow. For the older LUD-21 spec, this should be 0. For the newer
     * LUD-21 spec, this should be 1.
     */
    umaMajorVersion: number;
    /**
     * associated invoice id, for PayRequest version1+
     */
    invoiceUUID?: string | undefined;
    /**
     *  The data that the sender must send to the receiver to identify themselves. This should
     *  include the mandatory fields requested by the receiver in the `LnurlpResponse`
     */
    payerData?: PayerData | undefined;
    /**
     * The settlement layer and asset that the sender wants to use for this payment.
     * If not specified, the payment will be settled on Lightning using BTC.
     */
    settlement?: SettlementInfo | undefined;
};
/**
 * Creates a signed uma pay request.
 */
declare function getPayRequest({ amount, receivingCurrencyCode, isAmountInReceivingCurrency, payerEmail, payerIdentifier, payerKycStatus, payerName, payerNodePubKey, payerUtxos, receiverEncryptionPubKey, sendingVaspPrivateKey, trInfo, travelRuleFormat, utxoCallback, requestedPayeeData, comment, umaMajorVersion, invoiceUUID, payerData, settlement, }: GetPayRequestArgs): Promise<PayRequest>;
type PayRequestResponseArgs = {
    /** The uma pay request. */
    request: PayRequest;
    /**
     * The metadata that will be added to the invoice's metadata hash field. Note that this should not include the
     * extra payer data. That will be appended automatically.
     */
    metadata: string;
    /** UmaInvoiceCreator that calls createUmaInvoice using your provider. */
    invoiceCreator: UmaInvoiceCreator;
    /**
     * Milli-satoshis per the smallest unit of the specified currency. This rate is committed to by the receiving
     * VASP until the invoice expires.
     */
    conversionRate: number | undefined;
    /** The code of the currency that the receiver will receive for this payment. */
    receivingCurrencyCode: string | undefined;
    /**
     * Number of digits after the decimal point for the receiving currency. For example, in USD, by
     * convention, there are 2 digits for cents - $5.95. In this case, `decimals` would be 2. This should align with
     * the currency's `decimals` field in the LNURLP response. It is included here for convenience. See
     * [UMAD-04](https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md) for
     * details, edge cases, and examples.
     */
    receivingCurrencyDecimals: number | undefined;
    /** The list of UTXOs of the receiver's channels that might be used to fund the payment. */
    receiverChannelUtxos: string[] | undefined;
    /**
     * The fees charged (in millisats) by the receiving VASP to convert to the target currency. This is separate from
     * the conversion rate.
     */
    receiverFeesMillisats: number | undefined;
    /**
     * If known, the public key of the receiver's node. If supported by the sending VASP's compliance provider, this
     * will be used to pre-screen the receiver's UTXOs for compliance purposes.
     */
    receiverNodePubKey?: string | undefined;
    /**
     * The URL that the receiving VASP will call to send UTXOs of the channel that the receiver used to receive the
     * payment once it completes.
     */
    utxoCallback?: string | undefined;
    /**
     * The data requested by the sending VASP about the receiver.
     */
    payeeData?: PayeeData | undefined;
    /** The private key of the VASP that is receiving the payment. This will be used to sign the request. */
    receivingVaspPrivateKey: Uint8Array | undefined;
    /** The identifier of the receiver. For example, $bob@vasp2.com */
    payeeIdentifier: string | undefined;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable?: boolean | undefined;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction?: {
        [key: string]: string;
    } | undefined;
};
declare function getPayReqResponse({ request, conversionRate, receivingCurrencyCode, receivingCurrencyDecimals, invoiceCreator, metadata, receiverChannelUtxos, receiverFeesMillisats, receiverNodePubKey, utxoCallback, payeeData, receivingVaspPrivateKey, payeeIdentifier, disposable, successAction, }: PayRequestResponseArgs): Promise<PayReqResponse>;
type PayReqResponseForSettlementLayerArgs = {
    /** The uma pay request. */
    request: PayRequest;
    /**
     * The metadata that will be added to the invoice's metadata hash field. Note that this should not include the
     * extra payer data. That will be appended automatically.
     */
    metadata: string;
    /** UmaInvoiceCreator that calls createInvoiceForSettlementLayer using your provider. */
    invoiceCreator: UmaInvoiceCreator;
    /**
     * The conversion rate - how many of the smallest units of the settlement asset equal one unit of the receiving currency.
     * For example:
     * - Lightning/BTC: If 1 USD cent = 34,150 millisatoshis, then multiplier = 34150
     * - Spark USDC: If 1 USD cent = 100 token units, then multiplier = 100
     */
    conversionRate: number | undefined;
    /** The code of the currency that the receiver will receive for this payment. */
    receivingCurrencyCode: string | undefined;
    /**
     * Number of digits after the decimal point for the receiving currency. For example, in USD, by
     * convention, there are 2 digits for cents - $5.95. In this case, `decimals` would be 2. This should align with
     * the currency's `decimals` field in the LNURLP response. It is included here for convenience. See
     * [UMAD-04](https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md) for
     * details, edge cases, and examples.
     */
    receivingCurrencyDecimals: number | undefined;
    /**
     * The fees charged (in the smallest unit of the settlement asset, ie. msats for Lightning) by the receiving VASP
     * to convert to the target currency. This is separate from the conversion rate.
     */
    receiverFees: number | undefined;
    /**
     * If known, the public key of the receiver's node. If supported by the sending VASP's compliance provider, this
     * will be used to pre-screen the receiver's UTXOs for compliance purposes. Only applicable to Lightning.
     */
    receiverNodePubKey?: string | undefined;
    /**
     * The URL that the receiving VASP will call to send UTXOs of the channel that the receiver used to receive the
     * payment once it completes.
     */
    utxoCallback?: string | undefined;
    /**
     * The data requested by the sending VASP about the receiver.
     */
    payeeData?: PayeeData | undefined;
    /** The private key of the VASP that is receiving the payment. This will be used to sign the request. */
    receivingVaspPrivateKey: Uint8Array | undefined;
    /** The identifier of the receiver. For example, $bob@vasp2.com */
    payeeIdentifier: string | undefined;
    /**
     * This field may be used by a WALLET to decide whether the initial LNURL link will
     * be stored locally for later reuse or erased. If disposable is null, it should be
     * interpreted as true, so if SERVICE intends its LNURL links to be stored it must
     * return `disposable: false`. UMA should always return `disposable: false`. See LUD-11.
     */
    disposable?: boolean | undefined;
    /**
     * Defines a struct which can be stored and shown to the user on payment success. See LUD-09.
     */
    successAction?: {
        [key: string]: string;
    } | undefined;
};
declare function getPayReqResponseForSettlementLayer({ request, conversionRate, receivingCurrencyCode, receivingCurrencyDecimals, invoiceCreator, metadata, receiverFees, receiverNodePubKey, utxoCallback, payeeData, receivingVaspPrivateKey, payeeIdentifier, disposable, successAction, }: PayReqResponseForSettlementLayerArgs): Promise<PayReqResponse>;
type GetSignedLnurlpResponseArgs = {
    request: LnurlpRequest;
    callback: string;
    encodedMetadata: string;
    minSendableSats: number;
    maxSendableSats: number;
    privateKeyBytes?: Uint8Array | undefined;
    requiresTravelRuleInfo?: boolean | undefined;
    payerDataOptions?: CounterPartyDataOptions | undefined;
    currencyOptions?: Currency[] | undefined;
    receiverKycStatus?: KycStatus | undefined;
    commentCharsAllowed?: number | undefined;
    nostrPubkey?: string | undefined;
    settlementOptions?: SettlementOption[] | undefined;
};
declare function getLnurlpResponse({ request, privateKeyBytes, requiresTravelRuleInfo, callback, encodedMetadata, minSendableSats, maxSendableSats, payerDataOptions, currencyOptions, receiverKycStatus, commentCharsAllowed, nostrPubkey, settlementOptions, }: GetSignedLnurlpResponseArgs): Promise<LnurlpResponse>;
type PostTransactionCallbackArgs = {
    /** UTXOs of the channels of the VASP initiating the callback. */
    utxos: UtxoWithAmount[];
    /** Domain name of the VASP sending the callback. Used to fetch keys for signature validation. */
    vaspDomain: string;
    /** The private signing key of the VASP that is sending the callback. This will be used to sign the request. */
    signingPrivateKey: Uint8Array;
};
declare function getPostTransactionCallback({ utxos, vaspDomain, signingPrivateKey, }: PostTransactionCallbackArgs): Promise<PostTransactionCallback>;
declare function verifyUmaLnurlpResponseSignature(response: LnurlpResponse, otherVaspPubKeyResponse: PubKeyResponse, nonceValidator: NonceValidator): Promise<boolean>;
/**
 * Verifies the backing signatures on an UMA Lnurlp response. You may optionally call this function after
 * verifyUmaLnurlpResponseSignature to verify signatures from backing VASPs.
 *
 * @param response The signed response to verify
 * @param cache The PublicKeyCache to use for fetching VASP public keys
 * @returns true if all backing signatures are valid, false otherwise
 */
declare function verifyUmaLnurlpResponseBackingSignatures(response: LnurlpResponse, cache: PublicKeyCache): Promise<boolean>;
declare function verifyPayReqSignature(query: PayRequest, otherVaspPubKeyResponse: PubKeyResponse, nonceValidator: NonceValidator): Promise<boolean>;
/**
 * Verifies the backing signatures on a PayRequest. You may optionally call this function after
 * verifyPayReqSignature to verify signatures from backing VASPs.
 *
 * @param query The signed PayRequest to verify
 * @param cache The PublicKeyCache to use for fetching VASP public keys
 * @returns true if all backing signatures are valid, false otherwise
 */
declare function verifyPayReqBackingSignatures(query: PayRequest, cache: PublicKeyCache): Promise<boolean>;
declare function verifyPayReqResponseSignature(response: PayReqResponse, payerIdentifier: string, payeeIdentifier: string, otherVaspPubKeyResponse: PubKeyResponse, nonceValidator: NonceValidator): Promise<boolean>;
/**
 * Verifies the backing signatures on a PayReqResponse. You may optionally call this function after
 * verifyPayReqResponseSignature to verify signatures from backing VASPs.
 *
 * @param response The signed PayReqResponse to verify
 * @param payerIdentifier The identifier of the sender (e.g. $alice@vasp1.com)
 * @param payeeIdentifier The identifier of the receiver
 * @param cache Cache for storing VASP public keys
 * @returns true if all backing signatures are valid, false otherwise
 */
declare function verifyPayReqResponseBackingSignatures(response: PayReqResponse, payerIdentifier: string, payeeIdentifier: string, cache: PublicKeyCache): Promise<boolean>;
declare function verifyPostTransactionCallbackSignature(callback: PostTransactionCallback, otherVaspPubKeyResponse: PubKeyResponse, nonceValidator: NonceValidator): Promise<boolean>;
declare function createUmaInvoice({ receiverUma, invoiceUUID, amount, receivingCurrency, expiration, isSubjectToTravelRule, requiredPayerData, commentCharsAllowed, senderUma, invoiceLimit, kycStatus, callback, }: {
    receiverUma: string;
    invoiceUUID: string;
    amount: number;
    receivingCurrency: InvoiceCurrency;
    expiration: number;
    isSubjectToTravelRule: boolean;
    requiredPayerData: CounterPartyDataOptions | undefined;
    commentCharsAllowed: number | undefined;
    senderUma: string | undefined;
    invoiceLimit: number | undefined;
    kycStatus: KycStatus | undefined;
    callback: string;
}, privateKeyBytes: Uint8Array): Promise<Invoice>;

declare const MAJOR_VERSION = 1;
declare const MINOR_VERSION = 0;
declare const UmaProtocolVersion = "1.0";
declare class UnsupportedVersionError extends UmaError {
    unsupportedVersion: string;
    supportedMajorVersions: number[];
    constructor(unsupportedVersion: string, supportedMajorVersions?: number[]);
    getAdditionalParams(): Record<string, unknown>;
}
declare function getHighestSupportedVersionForMajorVersion(majorVersion: number): string;
declare function selectHighestSupportedVersion(otherVaspSupportedMajorVersions: number[]): string;
declare function selectLowerVersion(version1String: string, version2String: string): string;
declare function isVersionSupported(version: string): boolean;
declare function getMajorVersion(version: string): number;
declare function getMinorVersion(version: string): number;
declare function parseVersion(version: string): {
    major: number;
    minor: number;
};
declare function getSupportedMajorVersions(): Set<number>;

export { CompliancePayeeData, CompliancePayeeDataSchema, CompliancePayerData, CounterPartyDataKey, CounterPartyDataKeys, CounterPartyDataOption, CounterPartyDataOptionSchema, CounterPartyDataOptions, CounterPartyDataOptionsSchema, Currency, CurrencySchema, ErrorCode, ErrorDetails, InMemoryNonceValidator, InMemoryPublicKeyCache, InvalidInputError, Invoice, InvoiceCurrency, InvoiceSerializer, KycStatus, LnurlComplianceResponse, LnurlpRequest, LnurlpResponse, MAJOR_VERSION, MINOR_VERSION, NonceValidator, PayReqResponse, PayReqResponseComplianceSchema, PayReqResponsePaymentInfo, PayReqResponsePaymentInfoSchema, PayReqResponseSchema, PayRequest, PayRequestSchema, PayeeData, PayeeDataSchema, PayerData, PayerDataSchema, PostTransactionCallback, PostTransactionCallbackSchema, PubKeyResponse, PublicKeyCache, Route, RouteSchema, SettlementAsset, SettlementAssetSchema, SettlementInfo, SettlementInfoSchema, SettlementOption, SettlementOptionSchema, UmaError, UmaProtocolVersion, UnsupportedVersionError, UtxoWithAmount, UtxoWithAmountSchema, V0PayReqResponseComplianceSchema, V1CurrencySchema, appendBackingSignature, counterPartyDataOptionsFromBytes, counterPartyDataOptionsToBytes, createInvoiceWithSettlement, createSha256Hash, createUmaInvoice, encodeToUrl, fetchPublicKeyForVasp, generateNonce, getHighestSupportedVersionForMajorVersion, getLnurlpResponse, getMajorVersion, getMinorVersion, getPayReqResponse, getPayReqResponseForSettlementLayer, getPayRequest, getPostTransactionCallback, getPubKeyResponse, getSignableLnurlpRequestPayload, getSignablePostTransactionCallback, getSignedLnurlpRequestUrl, getSupportedMajorVersions, getVaspDomainFromUmaAddress, isError, isLnurlpRequestForUma, isUmaLnurlpQuery, isValidUmaAddress, isVersionSupported, kycStatusFromBytes, kycStatusFromString, kycStatusToBytes, kycStatusToString, parseLnurlpRequest, parsePostTransactionCallback, parseVersion, selectHighestSupportedVersion, selectLowerVersion, signBytePayload, signPayload, uint8ArrayToHexString, verifyPayReqBackingSignatures, verifyPayReqResponseBackingSignatures, verifyPayReqResponseSignature, verifyPayReqSignature, verifyPostTransactionCallbackSignature, verifyUmaInvoiceSignature, verifyUmaLnurlpQueryBackingSignatures, verifyUmaLnurlpQuerySignature, verifyUmaLnurlpResponseBackingSignatures, verifyUmaLnurlpResponseSignature };