@lightsparkdev/lightspark-sdk 0.1.6

package/dist/Withdrawal-17e1c8af.d.ts

@@ -0,0 +1,1672 @@
+import { Maybe, Query, AuthProvider, NodeKeyCache } from '@lightsparkdev/core';
+import Observable from 'zen-observable';
+
+declare enum CurrencyUnit {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /** Bitcoin is the cryptocurrency native to the Bitcoin network. It is used as the native medium for value transfer for the Lightning Network. **/
+    BITCOIN = "BITCOIN",
+    /** 0.00000001 (10e-8) Bitcoin or one hundred millionth of a Bitcoin. This is the unit most commonly used in Lightning transactions. **/
+    SATOSHI = "SATOSHI",
+    /** 0.001 Satoshi, or 10e-11 Bitcoin. We recommend using the Satoshi unit instead when possible. **/
+    MILLISATOSHI = "MILLISATOSHI",
+    /** United States Dollar. **/
+    USD = "USD",
+    /** 0.000000001 (10e-9) Bitcoin or a billionth of a Bitcoin. We recommend using the Satoshi unit instead when possible. **/
+    NANOBITCOIN = "NANOBITCOIN",
+    /** 0.000001 (10e-6) Bitcoin or a millionth of a Bitcoin. We recommend using the Satoshi unit instead when possible. **/
+    MICROBITCOIN = "MICROBITCOIN",
+    /** 0.001 (10e-3) Bitcoin or a thousandth of a Bitcoin. We recommend using the Satoshi unit instead when possible. **/
+    MILLIBITCOIN = "MILLIBITCOIN"
+}
+
+/** Represents the value and unit for an amount of currency. **/
+type CurrencyAmount = {
+    /** The original numeric value for this CurrencyAmount. **/
+    originalValue: number;
+    /** The original unit of currency for this CurrencyAmount. **/
+    originalUnit: CurrencyUnit;
+    /** The unit of user's preferred currency. **/
+    preferredCurrencyUnit: CurrencyUnit;
+    /**
+     * The rounded numeric value for this CurrencyAmount in the very base level of user's preferred
+     * currency. For example, for USD, the value will be in cents.
+     **/
+    preferredCurrencyValueRounded: number;
+    /**
+     * The approximate float value for this CurrencyAmount in the very base level of user's preferred
+     * currency. For example, for USD, the value will be in cents.
+     **/
+    preferredCurrencyValueApprox: number;
+};
+
+declare enum LightsparkNodePurpose {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    SEND = "SEND",
+    RECEIVE = "RECEIVE",
+    ROUTING = "ROUTING"
+}
+
+declare enum LightsparkNodeStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    CREATED = "CREATED",
+    DEPLOYED = "DEPLOYED",
+    STARTED = "STARTED",
+    SYNCING = "SYNCING",
+    READY = "READY",
+    STOPPED = "STOPPED",
+    TERMINATED = "TERMINATED",
+    WALLET_LOCKED = "WALLET_LOCKED",
+    FAILED_TO_DEPLOY = "FAILED_TO_DEPLOY"
+}
+
+/** An enum that enumerates all possible types of addresses of a node on the Lightning Network. **/
+declare enum NodeAddressType {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    IPV4 = "IPV4",
+    IPV6 = "IPV6",
+    TOR = "TOR"
+}
+
+type AccountDashboard = {
+    id: string;
+    name: Maybe<string>;
+    nodes: {
+        id: string;
+        color: Maybe<string>;
+        displayName: string;
+        purpose: Maybe<LightsparkNodePurpose>;
+        publicKey: Maybe<string>;
+        status: Maybe<LightsparkNodeStatus>;
+        addresses: {
+            count: number;
+            entities: {
+                address: string;
+                type: NodeAddressType;
+            }[];
+        };
+        localBalance: Maybe<CurrencyAmount>;
+        remoteBalance: Maybe<CurrencyAmount>;
+        blockchainBalance: {
+            availableBalance: Maybe<CurrencyAmount>;
+            totalBalance: Maybe<CurrencyAmount>;
+        } | null;
+    }[];
+    blockchainBalance: Maybe<{
+        l1Balance: Maybe<CurrencyAmount>;
+        requiredReserve: Maybe<CurrencyAmount>;
+        availableBalance: Maybe<CurrencyAmount>;
+        unconfirmedBalance: Maybe<CurrencyAmount>;
+    }>;
+    localBalance: Maybe<CurrencyAmount>;
+    remoteBalance: Maybe<CurrencyAmount>;
+};
+
+declare enum BitcoinNetwork {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /** The production version of the Bitcoin Blockchain. **/
+    MAINNET = "MAINNET",
+    /** A test version of the Bitcoin Blockchain, maintained by Lightspark. **/
+    REGTEST = "REGTEST",
+    /** A test version of the Bitcoin Blockchain, maintained by a centralized organization. Not in use at Lightspark. **/
+    SIGNET = "SIGNET",
+    /** A test version of the Bitcoin Blockchain, publically available. **/
+    TESTNET = "TESTNET"
+}
+
+/** This interface is used by all the entities in the Lightspark systems. It defines a few core fields that are available everywhere. Any object that implements this interface can be queried using the `entity` query and its ID. **/
+type Entity = {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The typename of the object **/
+    typename: string;
+};
+
+declare enum Permission {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    ALL = "ALL",
+    MAINNET_VIEW = "MAINNET_VIEW",
+    MAINNET_TRANSACT = "MAINNET_TRANSACT",
+    MAINNET_MANAGE = "MAINNET_MANAGE",
+    TESTNET_VIEW = "TESTNET_VIEW",
+    TESTNET_TRANSACT = "TESTNET_TRANSACT",
+    TESTNET_MANAGE = "TESTNET_MANAGE",
+    REGTEST_VIEW = "REGTEST_VIEW",
+    REGTEST_TRANSACT = "REGTEST_TRANSACT",
+    REGTEST_MANAGE = "REGTEST_MANAGE",
+    USER_VIEW = "USER_VIEW",
+    USER_MANAGE = "USER_MANAGE",
+    ACCOUNT_VIEW = "ACCOUNT_VIEW",
+    ACCOUNT_MANAGE = "ACCOUNT_MANAGE"
+}
+
+type ApiToken = Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /**
+     * An opaque identifier that should be used as a client_id (or username) in the HTTP Basic
+     * Authentication scheme when issuing requests against the Lightspark API.
+     **/
+    clientId: string;
+    /**
+     * An arbitrary name chosen by the creator of the token to help identify the token in the list of
+     * tokens that have been created for the account.
+     **/
+    name: string;
+    /** A list of permissions granted to the token. **/
+    permissions: Permission[];
+    /** The typename of the object **/
+    typename: string;
+};
+declare const getApiTokenQuery: (id: string) => Query<ApiToken>;
+
+type CreateApiTokenOutput = {
+    /** The API Token that has been created. **/
+    apiToken: ApiToken;
+    /**
+     * The secret that should be used to authenticate against our API. This secret is not stored and will
+     * never be available again after this. You must keep this secret secure as it grants access to your
+     * account.
+     **/
+    clientSecret: string;
+};
+
+type FeeEstimate = {
+    feeFast: CurrencyAmount;
+    feeMin: CurrencyAmount;
+};
+
+/** An object that represents the address of a node on the Lightning Network. **/
+type NodeAddress = {
+    /** The string representation of the address. **/
+    address: string;
+    /** The type, or protocol, of this address. **/
+    type: NodeAddressType;
+};
+
+/** A connection between a node and the addresses it has announced for itself on Lightning Network. **/
+type NodeToAddressesConnection = {
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The addresses for the current page of this connection. **/
+    entities: NodeAddress[];
+};
+
+/** This interface represents a lightning node that can be connected to the Lightning Network to send and receive transactions. **/
+declare class Node implements Entity {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly bitcoinNetwork: BitcoinNetwork;
+    readonly displayName: string;
+    readonly typename: string;
+    readonly alias?: string | undefined;
+    readonly color?: string | undefined;
+    readonly conductivity?: number | undefined;
+    readonly publicKey?: string | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, bitcoinNetwork: BitcoinNetwork, displayName: string, typename: string, alias?: string | undefined, color?: string | undefined, conductivity?: number | undefined, publicKey?: string | undefined);
+    getAddresses(client: LightsparkClient, first?: number | undefined, types?: NodeAddressType[] | undefined): Promise<NodeToAddressesConnection>;
+    static getNodeQuery(id: string): Query<Node>;
+}
+
+/** The interface of a payment request on the Lightning Network (a.k.a. Lightning Invoice). **/
+type PaymentRequestData = {
+    encodedPaymentRequest: string;
+    bitcoinNetwork: BitcoinNetwork;
+    /** The typename of the object **/
+    typename: string;
+};
+
+/** This object represents the BOLT #11 invoice protocol for Lightning Payments. See https://github.com/lightning/bolts/blob/master/11-payment-encoding.md. **/
+type InvoiceData = PaymentRequestData & {
+    encodedPaymentRequest: string;
+    bitcoinNetwork: BitcoinNetwork;
+    paymentHash: string;
+    amount: CurrencyAmount;
+    createdAt: string;
+    expiresAt: string;
+    destination: Node;
+    /** The typename of the object **/
+    typename: string;
+    memo?: string;
+};
+
+declare enum InvoiceType {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /** A standard Bolt 11 invoice. **/
+    STANDARD = "STANDARD",
+    /** An AMP (Atomic Multi-path Payment) invoice. **/
+    AMP = "AMP"
+}
+
+declare enum TransactionStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /** Transaction succeeded.. **/
+    SUCCESS = "SUCCESS",
+    /** Transaction failed. **/
+    FAILED = "FAILED",
+    /** Transaction has been initiated and is currently in-flight. **/
+    PENDING = "PENDING",
+    /** For transaction type PAYMENT_REQUEST only. No payments have been made to a payment request. **/
+    NOT_STARTED = "NOT_STARTED",
+    /** For transaction type PAYMENT_REQUEST only. A payment request has expired. **/
+    EXPIRED = "EXPIRED",
+    /** For transaction type PAYMENT_REQUEST only. **/
+    CANCELLED = "CANCELLED"
+}
+
+type Transaction = Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+};
+declare const getTransactionQuery: (id: string) => Query<Transaction>;
+
+type LightningTransaction = Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+};
+declare const getLightningTransactionQuery: (id: string) => Query<LightningTransaction>;
+
+declare enum HtlcAttemptFailureCode {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS = "INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS",
+    INCORRECT_PAYMENT_AMOUNT = "INCORRECT_PAYMENT_AMOUNT",
+    FINAL_INCORRECT_CLTV_EXPIRY = "FINAL_INCORRECT_CLTV_EXPIRY",
+    FINAL_INCORRECT_HTLC_AMOUNT = "FINAL_INCORRECT_HTLC_AMOUNT",
+    FINAL_EXPIRY_TOO_SOON = "FINAL_EXPIRY_TOO_SOON",
+    INVALID_REALM = "INVALID_REALM",
+    EXPIRY_TOO_SOON = "EXPIRY_TOO_SOON",
+    INVALID_ONION_VERSION = "INVALID_ONION_VERSION",
+    INVALID_ONION_HMAC = "INVALID_ONION_HMAC",
+    INVALID_ONION_KEY = "INVALID_ONION_KEY",
+    AMOUNT_BELOW_MINIMUM = "AMOUNT_BELOW_MINIMUM",
+    FEE_INSUFFICIENT = "FEE_INSUFFICIENT",
+    INCORRECT_CLTV_EXPIRY = "INCORRECT_CLTV_EXPIRY",
+    CHANNEL_DISABLED = "CHANNEL_DISABLED",
+    TEMPORARY_CHANNEL_FAILURE = "TEMPORARY_CHANNEL_FAILURE",
+    REQUIRED_NODE_FEATURE_MISSING = "REQUIRED_NODE_FEATURE_MISSING",
+    REQUIRED_CHANNEL_FEATURE_MISSING = "REQUIRED_CHANNEL_FEATURE_MISSING",
+    UNKNOWN_NEXT_PEER = "UNKNOWN_NEXT_PEER",
+    TEMPORARY_NODE_FAILURE = "TEMPORARY_NODE_FAILURE",
+    PERMANENT_NODE_FAILURE = "PERMANENT_NODE_FAILURE",
+    PERMANENT_CHANNEL_FAILURE = "PERMANENT_CHANNEL_FAILURE",
+    EXPIRY_TOO_FAR = "EXPIRY_TOO_FAR",
+    MPP_TIMEOUT = "MPP_TIMEOUT",
+    INVALID_ONION_PAYLOAD = "INVALID_ONION_PAYLOAD",
+    INTERNAL_FAILURE = "INTERNAL_FAILURE",
+    UNKNOWN_FAILURE = "UNKNOWN_FAILURE",
+    UNREADABLE_FAILURE = "UNREADABLE_FAILURE"
+}
+
+/** Enum that enumerates all the possible status of an outgoing payment attempt. **/
+declare enum OutgoingPaymentAttemptStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    IN_FLIGHT = "IN_FLIGHT",
+    SUCCEEDED = "SUCCEEDED",
+    FAILED = "FAILED"
+}
+
+/** One hop signifies a payment moving one node ahead on a payment route; a list of sequential hops defines the path from sender node to recipient node for a payment attempt. **/
+type Hop = Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The zero-based index position of this hop in the path **/
+    index: number;
+    /** The typename of the object **/
+    typename: string;
+    /** The destination node of the hop. **/
+    destinationId?: string;
+    /** The public key of the node to which the hop is bound. **/
+    publicKey?: string;
+    /** The amount that is to be forwarded to the destination node. **/
+    amountToForward?: CurrencyAmount;
+    /** The fees to be collected by the source node for forwarding the payment over the hop. **/
+    fee?: CurrencyAmount;
+    /** The block height at which an unsettled HTLC is considered expired. **/
+    expiryBlockHeight?: number;
+};
+declare const getHopQuery: (id: string) => Query<Hop>;
+
+/** The connection from an outgoing payment attempt to the list of sequential hops that define the path from sender node to recipient node. **/
+type OutgoingPaymentAttemptToHopsConnection = {
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The hops for the current page of this connection. **/
+    entities: Hop[];
+};
+
+/** An attempt for a payment over a route from sender node to recipient node. **/
+declare class OutgoingPaymentAttempt implements Entity {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly status: OutgoingPaymentAttemptStatus;
+    readonly outgoingPaymentId: string;
+    readonly typename: string;
+    readonly failureCode?: HtlcAttemptFailureCode | undefined;
+    readonly failureSourceIndex?: number | undefined;
+    readonly resolvedAt?: string | undefined;
+    readonly amount?: CurrencyAmount | undefined;
+    readonly fees?: CurrencyAmount | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, status: OutgoingPaymentAttemptStatus, outgoingPaymentId: string, typename: string, failureCode?: HtlcAttemptFailureCode | undefined, failureSourceIndex?: number | undefined, resolvedAt?: string | undefined, amount?: CurrencyAmount | undefined, fees?: CurrencyAmount | undefined);
+    getHops(client: LightsparkClient, first?: number | undefined): Promise<OutgoingPaymentAttemptToHopsConnection>;
+    static getOutgoingPaymentAttemptQuery(id: string): Query<OutgoingPaymentAttempt>;
+}
+
+/** The connection from outgoing payment to all attempts. **/
+type OutgoingPaymentToAttemptsConnection = {
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The attempts for the current page of this connection. **/
+    entities: OutgoingPaymentAttempt[];
+};
+
+declare enum PaymentFailureReason {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    NONE = "NONE",
+    TIMEOUT = "TIMEOUT",
+    NO_ROUTE = "NO_ROUTE",
+    ERROR = "ERROR",
+    INCORRECT_PAYMENT_DETAILS = "INCORRECT_PAYMENT_DETAILS",
+    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE",
+    INVOICE_ALREADY_PAID = "INVOICE_ALREADY_PAID",
+    SELF_PAYMENT = "SELF_PAYMENT",
+    INVOICE_EXPIRED = "INVOICE_EXPIRED"
+}
+
+type RichText = {
+    text: string;
+};
+
+/** A transaction that was sent from a Lightspark node on the Lightning Network. **/
+declare class OutgoingPayment implements LightningTransaction {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly status: TransactionStatus;
+    readonly amount: CurrencyAmount;
+    readonly originId: string;
+    readonly typename: string;
+    readonly resolvedAt?: string | undefined;
+    readonly transactionHash?: string | undefined;
+    readonly destinationId?: string | undefined;
+    readonly fees?: CurrencyAmount | undefined;
+    readonly paymentRequestData?: PaymentRequestData | undefined;
+    readonly failureReason?: PaymentFailureReason | undefined;
+    readonly failureMessage?: RichText | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, status: TransactionStatus, amount: CurrencyAmount, originId: string, typename: string, resolvedAt?: string | undefined, transactionHash?: string | undefined, destinationId?: string | undefined, fees?: CurrencyAmount | undefined, paymentRequestData?: PaymentRequestData | undefined, failureReason?: PaymentFailureReason | undefined, failureMessage?: RichText | undefined);
+    getAttempts(client: LightsparkClient, first?: number | undefined): Promise<OutgoingPaymentToAttemptsConnection>;
+    static getOutgoingPaymentQuery(id: string): Query<OutgoingPayment>;
+}
+
+type TransactionUpdate = {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+};
+
+type WalletDashboard = {
+    id: string;
+    displayName: string;
+    purpose: Maybe<LightsparkNodePurpose>;
+    color: Maybe<string>;
+    publicKey: Maybe<string>;
+    status: Maybe<LightsparkNodeStatus>;
+    addresses: {
+        address: string;
+        type: NodeAddressType;
+    }[];
+    totalBalance: Maybe<CurrencyAmount>;
+    totalLocalBalance: Maybe<CurrencyAmount>;
+    onlineLocalBalance: Maybe<CurrencyAmount>;
+    remoteBalance: Maybe<CurrencyAmount>;
+    blockchainBalance: {
+        availableBalance: Maybe<CurrencyAmount>;
+        totalBalance: Maybe<CurrencyAmount>;
+        confirmedBalance: Maybe<CurrencyAmount>;
+        unconfirmedBalance: Maybe<CurrencyAmount>;
+    } | null;
+    recentTransactions: Transaction[];
+};
+
+declare enum WithdrawalMode {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    WALLET_ONLY = "WALLET_ONLY",
+    WALLET_THEN_CHANNELS = "WALLET_THEN_CHANNELS"
+}
+
+declare enum WithdrawalRequestStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESSFUL = "SUCCESSFUL"
+}
+
+/** Transaction happened on Bitcoin blockchain. **/
+type OnChainTransaction = Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /**
+     * The height of the block that included this transaction. This will be zero for unconfirmed
+     * transactions.
+     **/
+    blockHeight: number;
+    /** The Bitcoin blockchain addresses this transaction was sent to. **/
+    destinationAddresses: string[];
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+    /**
+     * The fees that were paid by the wallet sending the transaction to commit it to the Bitcoin
+     * blockchain.
+     **/
+    fees?: CurrencyAmount;
+    /**
+     * The hash of the block that included this transaction. This will be null for unconfirmed
+     * transactions.
+     **/
+    blockHash?: string;
+    /** The number of blockchain confirmations for this transaction in real time. **/
+    numConfirmations?: number;
+};
+declare const getOnChainTransactionQuery: (id: string) => Query<OnChainTransaction>;
+
+/** The transaction on Bitcoin blockchain to close a channel on Lightning Network where the balances are allocated back to local and remote nodes. **/
+type ChannelClosingTransaction = OnChainTransaction & Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /**
+     * The height of the block that included this transaction. This will be zero for unconfirmed
+     * transactions.
+     **/
+    blockHeight: number;
+    /** The Bitcoin blockchain addresses this transaction was sent to. **/
+    destinationAddresses: string[];
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+    /**
+     * The fees that were paid by the wallet sending the transaction to commit it to the Bitcoin
+     * blockchain.
+     **/
+    fees?: CurrencyAmount;
+    /**
+     * The hash of the block that included this transaction. This will be null for unconfirmed
+     * transactions.
+     **/
+    blockHash?: string;
+    /** The number of blockchain confirmations for this transaction in real time. **/
+    numConfirmations?: number;
+    /** If known, the channel this transaction is closing. **/
+    channelId?: string;
+};
+declare const getChannelClosingTransactionQuery: (id: string) => Query<ChannelClosingTransaction>;
+
+type PageInfo = {
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+    startCursor?: string;
+    endCursor?: string;
+};
+
+type WithdrawalRequestToChannelClosingTransactionsConnection = {
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The channel closing transactions for the current page of this connection. **/
+    entities: ChannelClosingTransaction[];
+};
+
+/** The transaction on Bitcoin blockchain to open a channel on Lightning Network funded by the local Lightspark node. **/
+type ChannelOpeningTransaction = OnChainTransaction & Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /**
+     * The height of the block that included this transaction. This will be zero for unconfirmed
+     * transactions.
+     **/
+    blockHeight: number;
+    /** The Bitcoin blockchain addresses this transaction was sent to. **/
+    destinationAddresses: string[];
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+    /**
+     * The fees that were paid by the wallet sending the transaction to commit it to the Bitcoin
+     * blockchain.
+     **/
+    fees?: CurrencyAmount;
+    /**
+     * The hash of the block that included this transaction. This will be null for unconfirmed
+     * transactions.
+     **/
+    blockHash?: string;
+    /** The number of blockchain confirmations for this transaction in real time. **/
+    numConfirmations?: number;
+    /** If known, the channel this transaction is opening. **/
+    channelId?: string;
+};
+declare const getChannelOpeningTransactionQuery: (id: string) => Query<ChannelOpeningTransaction>;
+
+type WithdrawalRequestToChannelOpeningTransactionsConnection = {
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The channel opening transactions for the current page of this connection. **/
+    entities: ChannelOpeningTransaction[];
+};
+
+declare class WithdrawalRequest implements Entity {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly amount: CurrencyAmount;
+    readonly bitcoinAddress: string;
+    readonly withdrawalMode: WithdrawalMode;
+    readonly status: WithdrawalRequestStatus;
+    readonly typename: string;
+    readonly completedAt?: string | undefined;
+    readonly withdrawalId?: string | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, amount: CurrencyAmount, bitcoinAddress: string, withdrawalMode: WithdrawalMode, status: WithdrawalRequestStatus, typename: string, completedAt?: string | undefined, withdrawalId?: string | undefined);
+    getChannelClosingTransactions(client: LightsparkClient, first?: number | undefined): Promise<WithdrawalRequestToChannelClosingTransactionsConnection>;
+    getChannelOpeningTransactions(client: LightsparkClient, first?: number | undefined): Promise<WithdrawalRequestToChannelOpeningTransactionsConnection>;
+    static getWithdrawalRequestQuery(id: string): Query<WithdrawalRequest>;
+}
+
+/**
+ * The LightsparkClient is the main entrypoint for interacting with the Lightspark API.
+ *
+ * ```ts
+ * const lightsparkClient = new LightsparkClient(
+ *  new AccountTokenAuthProvider(TOKEN_ID, TOKEN_SECRET)
+ * );
+ * const encodedInvoice = await lightsparkClient.createInvoice(
+ *   RECEIVING_NODE_ID,
+ *   { value: 100, unit: CurrencyUnit.SATOSHI },
+ *   "Whasssupppp",
+ *   InvoiceType.AMP,
+ * );
+ *
+ * const invoiceDetails = await lightsparkClient.decodeInvoice(encodedInvoice);
+ * console.log(invoiceDetails);
+ *
+ * const payment = await lightsparkClient.payInvoice(PAYING_NODE_ID, encodedInvoice, 1000);
+ * console.log(payment);
+ * ```
+ *
+ * @class LightsparkClient
+ */
+declare class LightsparkClient {
+    private authProvider;
+    private readonly serverUrl;
+    private readonly nodeKeyCache;
+    private requester;
+    /**
+     * Constructs a new LightsparkClient.
+     *
+     * @param authProvider The auth provider to use for authentication. Defaults to a stub auth provider. For server-side
+     *     use, you should use the `AccountTokenAuthProvider`.
+     * @param serverUrl The base URL of the server to connect to. Defaults to lightspark production.
+     * @param nodeKeyCache This is used to cache node keys for the duration of the session. Defaults to a new instance of
+     *     `NodeKeyCache`. You should not need to change this.
+     */
+    constructor(authProvider?: AuthProvider, serverUrl?: string, nodeKeyCache?: NodeKeyCache);
+    /**
+     * Sets the auth provider for the client. This is useful for switching between auth providers if you are using
+     * multiple accounts or waiting for the user to log in.
+     *
+     * @param authProvider
+     */
+    setAuthProvider(authProvider: AuthProvider): Promise<void>;
+    /**
+     * @returns Whether or not the client is authorized. This is useful for determining if the user is logged in or not.
+     */
+    isAuthorized(): Promise<boolean>;
+    /**
+     * @returns The current account, if one exists.
+     */
+    getCurrentAccount(): Promise<Maybe<Account>>;
+    /**
+     * Retrieves the most recent transactions for a given node.
+     *
+     * @param nodeId The node ID for which to read transactions
+     * @param numTransactions The maximum number of transactions to read. Defaults to 20.
+     * @param bitcoinNetwork The bitcoin network on which to read transactions. Defaults to MAINNET.
+     * @param afterDate Filters transactions to those after the given date. Defaults to undefined (no limit).
+     * @returns An array of transactions for the given node ID.
+     */
+    getRecentTransactions(nodeId: string, numTransactions?: number, bitcoinNetwork?: BitcoinNetwork, afterDate?: Maybe<string>): Promise<Transaction[]>;
+    /**
+     * Starts listening for new transactions or updates to existing transactions for a list of nodes.
+     *
+     * @param nodeIds The node IDs for which to listen to transactions.
+     * @returns A zen-observable that emits transaction updates for the given node IDs.
+     */
+    listenToTransactions(nodeIds: string[]): Observable<TransactionUpdate | undefined>;
+    /**
+     * Retrieves a dashboard of basic info for the authenticated account. See `AccountDashboard` for which info is
+     * included.
+     *
+     * @param nodeIds The node IDs to include in the dashboard. Defaults to undefined (all nodes).
+     * @param bitcoinNetwork The bitcoin network to include in the dashboard. Defaults to MAINNET.
+     * @returns A basic account dashboard for the given node IDs.
+     * @throws LightsparkAuthException if the user is not logged in or a LightsparkException if no nodes are found.
+     */
+    getAccountDashboard(nodeIds?: string[] | undefined, bitcoinNetwork?: BitcoinNetwork): Promise<AccountDashboard>;
+    /**
+     * Gets a basic dashboard for a single node, including recent transactions. See `WalletDashboard` for which info is
+     * included.
+     *
+     * @param nodeId The node ID for which to get a dashboard.
+     * @param bitcoinNetwork The bitcoin network for which to get a dashboard. Defaults to MAINNET.
+     * @param transactionsAfterDate Filters recent transactions to those after the given date.
+     *     Defaults to undefined (no limit).
+     * @returns A basic dashboard for the given node ID.
+     */
+    getSingleNodeDashboard(nodeId: string, bitcoinNetwork?: BitcoinNetwork, transactionsAfterDate?: Maybe<string>): Promise<WalletDashboard>;
+    /**
+     * Creates an invoice for the given node.
+     *
+     * @param nodeId The node ID for which to create an invoice.
+     * @param amountMsats The amount of the invoice in msats. You can create a zero-amount invoice to accept any payment amount.
+     * @param memo A string memo to include in the invoice as a description.
+     * @param type The type of invoice to create. Defaults to a normal payment invoice, but you can pass InvoiceType.AMP
+     *     to create an [AMP invoice](https://docs.lightning.engineering/lightning-network-tools/lnd/amp), which can be
+     *     paid multiple times.
+     * @returns An encoded payment request for the invoice, or undefined if the invoice could not be created.
+     */
+    createInvoice(nodeId: string, amountMsats: number, memo: string, type?: InvoiceType | undefined): Promise<string | undefined>;
+    /**
+     * Decodes an encoded lightning invoice string.
+     *
+     * @param encodedInvoice The string encoded invoice to decode.
+     * @returns Decoded invoice data.
+     */
+    decodeInvoice(encodedInvoice: string): Promise<InvoiceData>;
+    /**
+     * Gets an estimate of the fee for sending a payment over the given bitcoin network.
+     *
+     * @param bitcoinNetwork The bitcoin network for which to get a fee estimate. Defaults to MAINNET.
+     * @returns A fee estimate for the given bitcoin network including a minimum fee rate, and a max-speed fee rate.
+     */
+    getBitcoinFeeEstimate(bitcoinNetwork?: BitcoinNetwork): Promise<FeeEstimate>;
+    /**
+     * Gets an estimate of the fees that will be paid for a Lightning invoice.
+     *
+     * @param nodeId The node from where you want to send the payment.
+     * @param encodedPaymentRequest The invoice you want to pay (as defined by the BOLT11 standard).
+     * @param amountMsats If the invoice does not specify a payment amount, then the amount that you wish to pay,
+     *     expressed in msats.
+     * @returns An estimate of the fees that will be paid for a Lightning invoice.
+     */
+    getLightningFeeEstimateForInvoice(nodeId: string, encodedPaymentRequest: string, amountMsats?: number | undefined): Promise<CurrencyAmount>;
+    /**
+     * Returns an estimate of the fees that will be paid to send a payment to another Lightning node.
+     *
+     * @param nodeId The node from where you want to send the payment.
+     * @param destinationNodePublicKey The public key of the node that you want to pay.
+     * @param amountMsats The payment amount expressed in msats.
+     * @returns An estimate of the fees that will be paid to send a payment to another Lightning node.
+     */
+    getLightningFeeEstimateForNode(nodeId: string, destinationNodePublicKey: string, amountMsats: number): Promise<CurrencyAmount>;
+    /**
+     * Unlock the given node for sensitive operations like sending payments.
+     *
+     * @param nodeId The ID of the node to unlock.
+     * @param password The node password assigned at node creation.
+     * @returns True if the node was unlocked successfully, false otherwise.
+     */
+    unlockNode(nodeId: string, password: string): Promise<boolean>;
+    private recoverNodeSigningKey;
+    /**
+     * Directly unlocks a node with a signing private key.
+     *
+     * @param nodeId The ID of the node to unlock.
+     * @param signingPrivateKeyPEM The PEM-encoded signing private key.
+     */
+    loadNodeKey(nodeId: string, signingPrivateKeyPEM: string): Promise<void>;
+    /**
+     * Sends a lightning payment for a given invoice.
+     *
+     * @param payerNodeId The ID of the node that will pay the invoice.
+     * @param encodedInvoice The encoded invoice to pay.
+     * @param maximumFeesMsats Maximum fees (in msats) to pay for the payment. This parameter is required.
+     *     As guidance, a maximum fee of 16 basis points should make almost all transactions succeed. For example,
+     *     for a transaction between 10k sats and 100k sats, this would mean a fee limit of 16 to 160 sats.
+     * @param timeoutSecs A timeout for the payment in seconds. Defaults to 60 seconds.
+     * @param amountMsats The amount to pay in msats for a zero-amount invoice. Defaults to the full amount of the
+     *     invoice. NOTE: This parameter can only be passed for a zero-amount invoice. Otherwise, the call will fail.
+     * @returns An `OutgoingPayment` object if the payment was successful, or undefined if the payment failed.
+     */
+    payInvoice(payerNodeId: string, encodedInvoice: string, maximumFeesMsats: number, timeoutSecs?: number, amountMsats?: number | undefined): Promise<OutgoingPayment | undefined>;
+    /**
+     * Sends a payment directly to a node on the Lightning Network through the public key of the node without an invoice.
+     *
+     * @param payerNodeId The ID of the node that will send the payment.
+     * @param destinationPublicKey The public key of the destination node.
+     * @param timeoutSecs The timeout in seconds that we will try to make the payment.
+     * @param amountMsats The amount to pay in msats.
+     * @param maximumFeesMsats Maximum fees (in msats) to pay for the payment. This parameter is required.
+     *     As guidance, a maximum fee of 15 basis points should make almost all transactions succeed. For example,
+     *     for a transaction between 10k sats and 100k sats, this would mean a fee limit of 15 to 150 sats.
+     * @returns An `OutgoingPayment` object if the payment was successful, or undefined if the payment failed.
+     */
+    sendPayment(payerNodeId: string, destinationPublicKey: string, timeoutSecs: number | undefined, amountMsats: number, maximumFeesMsats: number): Promise<OutgoingPayment | undefined>;
+    /**
+     * Creates an L1 Bitcoin wallet address for a given node which can be used to deposit or withdraw funds.
+     *
+     * @param nodeId The ID of the node to create a wallet address for.
+     * @returns A string containing the wallet address for the given node.
+     */
+    createNodeWalletAddress(nodeId: string): Promise<string>;
+    /**
+     * Withdraws funds from the account and sends it to the requested bitcoin address.
+     *
+     * Depending on the chosen mode, it will first take the funds from the wallet, and if applicable, close channels
+     * appropriately to recover enough funds and reopen channels with the remaining funds.
+     * The process is asynchronous and may take up to a few minutes. You can check the progress by polling the
+     * `WithdrawalRequest` that is created, or by subscribing to a webhook.
+     *
+     * @param nodeId The ID of the node from which to withdraw funds.
+     * @param amountSats The amount of funds to withdraw in satoshis.
+     * @param bitcoinAddress The Bitcoin address to withdraw funds to.
+     * @param mode The mode to use for the withdrawal. See `WithdrawalMode` for more information.
+     */
+    requestWithdrawal(nodeId: string, amountSats: number, bitcoinAddress: string, mode: WithdrawalMode): Promise<WithdrawalRequest>;
+    /**
+     * Adds funds to a Lightspark node on the REGTEST network. If the amount is not specified, 10,000,000 SATOSHI will be
+     * added. This API only functions for nodes created on the REGTEST network and will return an error when called for
+     * any non-REGTEST node.
+     *
+     * @param nodeId The ID of the node to fund. Must be a REGTEST node.
+     * @param amountSats The amount of funds to add to the node in satoshis. Defaults to 10,000,000 SATOSHI.
+     * @returns
+     */
+    fundNode(nodeId: string, amountSats?: number | undefined): Promise<CurrencyAmount>;
+    /**
+     * Creates a new API token that can be used to authenticate requests for this account when using the Lightspark APIs
+     * and SDKs.
+     *
+     * @param name Creates a new API token that can be used to authenticate requests for this account when using the
+     *     Lightspark APIs and SDKs.
+     * @param transact Whether the token should be able to transact or only view data.
+     * @param testMode True if the token should be able to access only testnet false to access only mainnet.
+     * @returns An object containing the API token and client secret.
+     */
+    createApiToken(name: string, transact?: boolean, testMode?: boolean): Promise<CreateApiTokenOutput>;
+    /**
+     * Deletes an existing API token from this account.
+     *
+     * @param id The ID of the API token to delete.
+     */
+    deleteApiToken(id: string): Promise<void>;
+    /**
+     * Executes a raw `Query` against the Lightspark API.
+     *
+     * This generally should not be used directly, but is exposed for advanced use cases and for internal use to retrieve
+     * complex fields from objects.
+     *
+     * @param query The `Query` to execute.
+     * @returns The result of the query.
+     */
+    executeRawQuery<T>(query: Query<T>): Promise<T | null>;
+}
+
+type AccountToApiTokensConnection = {
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The API tokens for the current page of this connection. **/
+    entities: ApiToken[];
+};
+
+type ChannelFees = {
+    baseFee?: CurrencyAmount;
+    feeRatePerMil?: number;
+};
+
+declare enum ChannelStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /** The channel is online and ready to send and receive funds. **/
+    OK = "OK",
+    /** The channel has been created, but the Bitcoin transaction that initiates it still needs to be confirmed on the Bitcoin blockchain. **/
+    PENDING = "PENDING",
+    /** The channel is not available, likely because the peer is not online. **/
+    OFFLINE = "OFFLINE",
+    /** The channel is behaving properly, but its remote balance is much higher than its local balance so it is not balanced properly for sending funds out. **/
+    UNBALANCED_FOR_SEND = "UNBALANCED_FOR_SEND",
+    /** The channel is behaving properly, but its remote balance is much lower than its local balance so it is not balanced properly for receiving funds. **/
+    UNBALANCED_FOR_RECEIVE = "UNBALANCED_FOR_RECEIVE",
+    /** The channel has been closed. Information about the channel is still available for historical purposes but the channel cannot be used anymore. **/
+    CLOSED = "CLOSED",
+    /** Something unexpected happened and we cannot determine the status of this channel. Please try again later or contact the support. **/
+    ERROR = "ERROR"
+}
+
+type ChannelToTransactionsConnection = {
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /**
+     * The average fee for the transactions that transited through this channel, according to the filters
+     * and constraints of the connection.
+     **/
+    averageFee?: CurrencyAmount;
+    /**
+     * The total amount transacted for the transactions that transited through this channel, according to
+     * the filters and constraints of the connection.
+     **/
+    totalAmountTransacted?: CurrencyAmount;
+    /**
+     * The total amount of fees for the transactions that transited through this channel, according to the
+     * filters and constraints of the connection.
+     **/
+    totalFees?: CurrencyAmount;
+};
+
+declare enum TransactionType {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /** Transactions initiated from a Lightspark node on Lightning Network. **/
+    OUTGOING_PAYMENT = "OUTGOING_PAYMENT",
+    /** Transactions received by a Lightspark node on Lightning Network. **/
+    INCOMING_PAYMENT = "INCOMING_PAYMENT",
+    /** Transactions that forwarded payments through Lightspark nodes on Lightning Network. **/
+    ROUTED = "ROUTED",
+    /** Transactions on the Bitcoin blockchain to withdraw funds from a Lightspark node to a Bitcoin wallet. **/
+    L1_WITHDRAW = "L1_WITHDRAW",
+    /** Transactions on Bitcoin blockchain to fund a Lightspark node's wallet. **/
+    L1_DEPOSIT = "L1_DEPOSIT",
+    /** Transactions on Bitcoin blockchain to open a channel on Lightning Network funded by the local Lightspark node. **/
+    CHANNEL_OPEN = "CHANNEL_OPEN",
+    /** Transactions on Bitcoin blockchain to close a channel on Lightning Network where the balances are allocated back to local and remote nodes. **/
+    CHANNEL_CLOSE = "CHANNEL_CLOSE",
+    /** Transactions initiated from a Lightspark node on Lightning Network. **/
+    PAYMENT = "PAYMENT",
+    /** Payment requests from a Lightspark node on Lightning Network **/
+    PAYMENT_REQUEST = "PAYMENT_REQUEST",
+    /** Transactions that forwarded payments through Lightspark nodes on Lightning Network. **/
+    ROUTE = "ROUTE"
+}
+
+/** An object that represents a payment channel between two nodes in the Lightning Network. **/
+declare class Channel implements Entity {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly localNodeId: string;
+    readonly typename: string;
+    readonly fundingTransactionId?: string | undefined;
+    readonly capacity?: CurrencyAmount | undefined;
+    readonly localBalance?: CurrencyAmount | undefined;
+    readonly localUnsettledBalance?: CurrencyAmount | undefined;
+    readonly remoteBalance?: CurrencyAmount | undefined;
+    readonly remoteUnsettledBalance?: CurrencyAmount | undefined;
+    readonly unsettledBalance?: CurrencyAmount | undefined;
+    readonly totalBalance?: CurrencyAmount | undefined;
+    readonly status?: ChannelStatus | undefined;
+    readonly estimatedForceClosureWaitMinutes?: number | undefined;
+    readonly commitFee?: CurrencyAmount | undefined;
+    readonly fees?: ChannelFees | undefined;
+    readonly remoteNodeId?: string | undefined;
+    readonly shortChannelId?: string | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, localNodeId: string, typename: string, fundingTransactionId?: string | undefined, capacity?: CurrencyAmount | undefined, localBalance?: CurrencyAmount | undefined, localUnsettledBalance?: CurrencyAmount | undefined, remoteBalance?: CurrencyAmount | undefined, remoteUnsettledBalance?: CurrencyAmount | undefined, unsettledBalance?: CurrencyAmount | undefined, totalBalance?: CurrencyAmount | undefined, status?: ChannelStatus | undefined, estimatedForceClosureWaitMinutes?: number | undefined, commitFee?: CurrencyAmount | undefined, fees?: ChannelFees | undefined, remoteNodeId?: string | undefined, shortChannelId?: string | undefined);
+    getUptimePercentage(client: LightsparkClient, afterDate?: string | undefined, beforeDate?: string | undefined): Promise<number>;
+    getTransactions(client: LightsparkClient, types?: TransactionType[] | undefined, afterDate?: string | undefined, beforeDate?: string | undefined): Promise<ChannelToTransactionsConnection>;
+    static getChannelQuery(id: string): Query<Channel>;
+}
+
+declare class AccountToChannelsConnection {
+    readonly count: number;
+    readonly entities: Channel[];
+    constructor(count: number, entities: Channel[]);
+}
+
+/** This object provides a detailed breakdown of a `LightsparkNode`'s current balance on the Bitcoin Network. **/
+type BlockchainBalance = {
+    /** The total wallet balance, including unconfirmed UTXOs. **/
+    totalBalance?: CurrencyAmount;
+    /** The balance of confirmed UTXOs in the wallet. **/
+    confirmedBalance?: CurrencyAmount;
+    /** The balance of unconfirmed UTXOs in the wallet. **/
+    unconfirmedBalance?: CurrencyAmount;
+    /** The balance that's locked by an on-chain transaction. **/
+    lockedBalance?: CurrencyAmount;
+    /** Funds required to be held in reserve for channel bumping. **/
+    requiredReserve?: CurrencyAmount;
+    /** Funds available for creating channels or withdrawing. **/
+    availableBalance?: CurrencyAmount;
+};
+
+type LightsparkNodeToChannelsConnection = {
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The channels for the current page of this connection. **/
+    entities: Channel[];
+};
+
+type Secret = {
+    encryptedValue: string;
+    cipher: string;
+};
+
+/** This is a node that is managed by Lightspark and is managed within the current connected account. It contains many details about the node configuration, state, and metadata. **/
+declare class LightsparkNode implements Node {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly bitcoinNetwork: BitcoinNetwork;
+    readonly displayName: string;
+    readonly accountId: string;
+    readonly typename: string;
+    readonly alias?: string | undefined;
+    readonly color?: string | undefined;
+    readonly conductivity?: number | undefined;
+    readonly publicKey?: string | undefined;
+    readonly blockchainBalance?: BlockchainBalance | undefined;
+    readonly encryptedSigningPrivateKey?: Secret | undefined;
+    readonly totalBalance?: CurrencyAmount | undefined;
+    readonly totalLocalBalance?: CurrencyAmount | undefined;
+    readonly localBalance?: CurrencyAmount | undefined;
+    readonly purpose?: LightsparkNodePurpose | undefined;
+    readonly remoteBalance?: CurrencyAmount | undefined;
+    readonly status?: LightsparkNodeStatus | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, bitcoinNetwork: BitcoinNetwork, displayName: string, accountId: string, typename: string, alias?: string | undefined, color?: string | undefined, conductivity?: number | undefined, publicKey?: string | undefined, blockchainBalance?: BlockchainBalance | undefined, encryptedSigningPrivateKey?: Secret | undefined, totalBalance?: CurrencyAmount | undefined, totalLocalBalance?: CurrencyAmount | undefined, localBalance?: CurrencyAmount | undefined, purpose?: LightsparkNodePurpose | undefined, remoteBalance?: CurrencyAmount | undefined, status?: LightsparkNodeStatus | undefined);
+    getAddresses(client: LightsparkClient, first?: number | undefined, types?: NodeAddressType[] | undefined): Promise<NodeToAddressesConnection>;
+    getChannels(client: LightsparkClient, first?: number | undefined, statuses?: ChannelStatus[] | undefined): Promise<LightsparkNodeToChannelsConnection>;
+    static getLightsparkNodeQuery(id: string): Query<LightsparkNode>;
+}
+
+/** A connection between an account and the nodes it manages. **/
+type AccountToNodesConnection = {
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The nodes for the current page of this connection. **/
+    entities: LightsparkNode[];
+    /**
+     * The main purpose for the selected set of nodes. It is automatically determined from the nodes that
+     * are selected in this connection and is used for optimization purposes, as well as to determine the
+     * variation of the UI that should be presented to the user.
+     **/
+    purpose?: LightsparkNodePurpose;
+};
+
+declare enum PaymentRequestStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    OPEN = "OPEN",
+    CLOSED = "CLOSED"
+}
+
+type PaymentRequest = Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The details of the payment request. **/
+    data: PaymentRequestData;
+    /** The status of the payment request. **/
+    status: PaymentRequestStatus;
+    /** The typename of the object **/
+    typename: string;
+};
+declare const getPaymentRequestQuery: (id: string) => Query<PaymentRequest>;
+
+type AccountToPaymentRequestsConnection = {
+    /** The payment requests for the current page of this connection. **/
+    entities: PaymentRequest[];
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count?: number;
+};
+
+type AccountToTransactionsConnection = {
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The transactions for the current page of this connection. **/
+    entities: Transaction[];
+    /** An object that holds pagination information about the objects in this connection. **/
+    pageInfo: PageInfo;
+    /**
+     * Profit (or loss) generated by the transactions in this connection, with the set of filters and
+     * constraints provided.
+     **/
+    profitLoss?: CurrencyAmount;
+    /**
+     * Average fee earned for the transactions in this connection, with the set of filters and constraints
+     * provided.
+     **/
+    averageFeeEarned?: CurrencyAmount;
+    /**
+     * Total amount transacted by the transactions in this connection, with the set of filters and
+     * constraints provided.
+     **/
+    totalAmountTransacted?: CurrencyAmount;
+};
+
+declare enum RoutingTransactionFailureReason {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    INCOMING_LINK_FAILURE = "INCOMING_LINK_FAILURE",
+    OUTGOING_LINK_FAILURE = "OUTGOING_LINK_FAILURE",
+    FORWARDING_FAILURE = "FORWARDING_FAILURE"
+}
+
+type TransactionFailures = {
+    paymentFailures?: PaymentFailureReason[];
+    routingTransactionFailures?: RoutingTransactionFailureReason[];
+};
+
+declare class Account implements Entity {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly typename: string;
+    readonly name?: string | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, typename: string, name?: string | undefined);
+    getApiTokens(client: LightsparkClient, first?: number | undefined): Promise<AccountToApiTokensConnection>;
+    getBlockchainBalance(client: LightsparkClient, bitcoinNetworks?: BitcoinNetwork[] | undefined, nodeIds?: string[] | undefined): Promise<BlockchainBalance | null>;
+    getConductivity(client: LightsparkClient, bitcoinNetworks?: BitcoinNetwork[] | undefined, nodeIds?: string[] | undefined): Promise<number>;
+    getLocalBalance(client: LightsparkClient, bitcoinNetworks?: BitcoinNetwork[] | undefined, nodeIds?: string[] | undefined): Promise<CurrencyAmount | null>;
+    getNodes(client: LightsparkClient, first?: number | undefined, bitcoinNetworks?: BitcoinNetwork[] | undefined, nodeIds?: string[] | undefined): Promise<AccountToNodesConnection>;
+    getRemoteBalance(client: LightsparkClient, bitcoinNetworks?: BitcoinNetwork[] | undefined, nodeIds?: string[] | undefined): Promise<CurrencyAmount | null>;
+    getUptimePercentage(client: LightsparkClient, afterDate?: string | undefined, beforeDate?: string | undefined, bitcoinNetworks?: BitcoinNetwork[] | undefined, nodeIds?: string[] | undefined): Promise<number>;
+    getChannels(client: LightsparkClient, bitcoinNetwork: BitcoinNetwork, lightningNodeId?: string | undefined, afterDate?: string | undefined, beforeDate?: string | undefined, first?: number | undefined): Promise<AccountToChannelsConnection>;
+    getTransactions(client: LightsparkClient, first?: number | undefined, after?: string | undefined, types?: TransactionType[] | undefined, afterDate?: string | undefined, beforeDate?: string | undefined, bitcoinNetwork?: BitcoinNetwork | undefined, lightningNodeId?: string | undefined, statuses?: TransactionStatus[] | undefined, excludeFailures?: TransactionFailures | undefined): Promise<AccountToTransactionsConnection>;
+    getPaymentRequests(client: LightsparkClient, first?: number | undefined, after?: string | undefined, afterDate?: string | undefined, beforeDate?: string | undefined, bitcoinNetwork?: BitcoinNetwork | undefined, lightningNodeId?: string | undefined): Promise<AccountToPaymentRequestsConnection>;
+    static getAccountQuery(): Query<Account>;
+}
+
+type CreateApiTokenInput = {
+    /** An arbitrary name that the user can choose to identify the API token in a list. **/
+    name: string;
+    /** List of permissions to grant to the API token **/
+    permissions: Permission[];
+};
+
+type CreateInvoiceInput = {
+    nodeId: string;
+    amountMsats: number;
+    memo?: string;
+    invoiceType?: InvoiceType;
+};
+
+type CreateInvoiceOutput = {
+    invoiceId: string;
+};
+
+type CreateNodeWalletAddressInput = {
+    nodeId: string;
+};
+
+type CreateNodeWalletAddressOutput = {
+    nodeId: string;
+    walletAddress: string;
+};
+
+type DeleteApiTokenInput = {
+    apiTokenId: string;
+};
+
+type DeleteApiTokenOutput = {
+    accountId: string;
+};
+
+/** The transaction on Bitcoin blockchain to fund the Lightspark node's wallet. **/
+type Deposit = OnChainTransaction & Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /**
+     * The height of the block that included this transaction. This will be zero for unconfirmed
+     * transactions.
+     **/
+    blockHeight: number;
+    /** The Bitcoin blockchain addresses this transaction was sent to. **/
+    destinationAddresses: string[];
+    /** The recipient Lightspark node this deposit was sent to. **/
+    destinationId: string;
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+    /**
+     * The fees that were paid by the wallet sending the transaction to commit it to the Bitcoin
+     * blockchain.
+     **/
+    fees?: CurrencyAmount;
+    /**
+     * The hash of the block that included this transaction. This will be null for unconfirmed
+     * transactions.
+     **/
+    blockHash?: string;
+    /** The number of blockchain confirmations for this transaction in real time. **/
+    numConfirmations?: number;
+};
+declare const getDepositQuery: (id: string) => Query<Deposit>;
+
+type FundNodeInput = {
+    nodeId: string;
+    amountSats?: number;
+};
+
+type FundNodeOutput = {
+    amount: CurrencyAmount;
+};
+
+/** This is a node on the Lightning Network, managed by a third party. The information about this node is public data that has been obtained by observing the Lightning Network. **/
+declare class GraphNode implements Node {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly bitcoinNetwork: BitcoinNetwork;
+    readonly displayName: string;
+    readonly typename: string;
+    readonly alias?: string | undefined;
+    readonly color?: string | undefined;
+    readonly conductivity?: number | undefined;
+    readonly publicKey?: string | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, bitcoinNetwork: BitcoinNetwork, displayName: string, typename: string, alias?: string | undefined, color?: string | undefined, conductivity?: number | undefined, publicKey?: string | undefined);
+    getAddresses(client: LightsparkClient, first?: number | undefined, types?: NodeAddressType[] | undefined): Promise<NodeToAddressesConnection>;
+    static getGraphNodeQuery(id: string): Query<GraphNode>;
+}
+
+/** Enum that enumerates all the possible status of an incoming payment attempt. **/
+declare enum IncomingPaymentAttemptStatus {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    ACCEPTED = "ACCEPTED",
+    SETTLED = "SETTLED",
+    CANCELED = "CANCELED",
+    UNKNOWN = "UNKNOWN"
+}
+
+/** An attempt for a payment over a route from sender node to recipient node. **/
+type IncomingPaymentAttempt = Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The status of the incoming payment attempt. **/
+    status: IncomingPaymentAttemptStatus;
+    /** The total amount of that was attempted to send. **/
+    amount: CurrencyAmount;
+    /** The channel this attempt was made on. **/
+    channelId: string;
+    /** The typename of the object **/
+    typename: string;
+    /** The time the incoming payment attempt failed or succeeded. **/
+    resolvedAt?: string;
+};
+declare const getIncomingPaymentAttemptQuery: (id: string) => Query<IncomingPaymentAttempt>;
+
+/** The connection from incoming payment to all attempts. **/
+type IncomingPaymentToAttemptsConnection = {
+    /**
+     * The total count of objects in this connection, using the current filters. It is different from the
+     * number of objects returned in the current page (in the `entities` field).
+     **/
+    count: number;
+    /** The incoming payment attempts for the current page of this connection. **/
+    entities: IncomingPaymentAttempt[];
+};
+
+/** A transaction that was sent to a Lightspark node on the Lightning Network. **/
+declare class IncomingPayment implements LightningTransaction {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly status: TransactionStatus;
+    readonly amount: CurrencyAmount;
+    readonly destinationId: string;
+    readonly typename: string;
+    readonly resolvedAt?: string | undefined;
+    readonly transactionHash?: string | undefined;
+    readonly originId?: string | undefined;
+    readonly paymentRequestId?: string | undefined;
+    constructor(id: string, createdAt: string, updatedAt: string, status: TransactionStatus, amount: CurrencyAmount, destinationId: string, typename: string, resolvedAt?: string | undefined, transactionHash?: string | undefined, originId?: string | undefined, paymentRequestId?: string | undefined);
+    getAttempts(client: LightsparkClient, first?: number | undefined, statuses?: IncomingPaymentAttemptStatus[] | undefined): Promise<IncomingPaymentToAttemptsConnection>;
+    static getIncomingPaymentQuery(id: string): Query<IncomingPayment>;
+}
+
+/** This object represents a BOLT #11 invoice (https://github.com/lightning/bolts/blob/master/11-payment-encoding.md) initiated by a Lightspark Node. **/
+type Invoice = PaymentRequest & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when the entity was first created. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The details of the invoice. **/
+    data: InvoiceData;
+    /** The status of the payment request. **/
+    status: PaymentRequestStatus;
+    /** The typename of the object **/
+    typename: string;
+    /** The total amount that has been paid to this invoice. **/
+    amountPaid?: CurrencyAmount;
+};
+declare const getInvoiceQuery: (id: string) => Query<Invoice>;
+
+type LightningFeeEstimateForInvoiceInput = {
+    /** The node from where you want to send the payment. **/
+    nodeId: string;
+    /** The invoice you want to pay (as defined by the BOLT11 standard). **/
+    encodedPaymentRequest: string;
+    /**
+     * If the invoice does not specify a payment amount, then the amount that you wish to pay, expressed
+     * in msats.
+     **/
+    amountMsats?: number;
+};
+
+type LightningFeeEstimateForNodeInput = {
+    /** The node from where you want to send the payment. **/
+    nodeId: string;
+    /** The public key of the node that you want to pay. **/
+    destinationNodePublicKey: string;
+    /** The payment amount expressed in msats. **/
+    amountMsats: number;
+};
+
+type LightningFeeEstimateOutput = {
+    /** The estimated fees for the payment. **/
+    feeEstimate: CurrencyAmount;
+};
+
+type PayInvoiceInput = {
+    /** The node from where you want to send the payment. **/
+    nodeId: string;
+    /** The invoice you want to pay (as defined by the BOLT11 standard). **/
+    encodedInvoice: string;
+    /** The timeout in seconds that we will try to make the payment. **/
+    timeoutSecs: number;
+    /** The maximum amount of fees that you want to pay for this payment to be sent, expressed in msats. **/
+    maximumFeesMsats: number;
+    /**
+     * The amount you will pay for this invoice, expressed in msats. It should ONLY be set when the
+     * invoice amount is zero.
+     **/
+    amountMsats?: number;
+};
+
+type PayInvoiceOutput = {
+    /** The payment that has been sent. **/
+    paymentId: string;
+};
+
+type RequestWithdrawalInput = {
+    /** The node from which you'd like to make the withdrawal. **/
+    nodeId: string;
+    /** The bitcoin address where the withdrawal should be sent. **/
+    bitcoinAddress: string;
+    /**
+     * The amount you want to withdraw from this node in Satoshis. Use the special value -1 to withdrawal
+     * all funds from this node.
+     **/
+    amountSats: number;
+    /** The strategy that should be used to withdraw the funds from this node. **/
+    withdrawalMode: WithdrawalMode;
+};
+
+type RequestWithdrawalOutput = {
+    /** The request that is created for this withdrawal. **/
+    requestId: string;
+};
+
+/** A transaction that was forwarded through a Lightspark node on the Lightning Network. **/
+type RoutingTransaction = LightningTransaction & Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+    /** If known, the channel this transaction was received from. **/
+    incomingChannelId?: string;
+    /** If known, the channel this transaction was forwarded to. **/
+    outgoingChannelId?: string;
+    /**
+     * The fees collected by the node when routing this transaction. We subtract the outgoing amount to
+     * the incoming amount to determine how much fees were collected.
+     **/
+    fees?: CurrencyAmount;
+    /** If applicable, user-facing error message describing why the routing failed. **/
+    failureMessage?: RichText;
+    /** If applicable, the reason why the routing failed. **/
+    failureReason?: RoutingTransactionFailureReason;
+};
+declare const getRoutingTransactionQuery: (id: string) => Query<RoutingTransaction>;
+
+type SendPaymentInput = {
+    /** The node from where you want to send the payment. **/
+    nodeId: string;
+    /** The public key of the destination node. **/
+    destinationPublicKey: string;
+    /** The timeout in seconds that we will try to make the payment. **/
+    timeoutSecs: number;
+    /** The amount you will send to the destination node, expressed in msats. **/
+    amountMsats: number;
+    /** The maximum amount of fees that you want to pay for this payment to be sent, expressed in msats. **/
+    maximumFeesMsats: number;
+};
+
+type SendPaymentOutput = {
+    /** The payment that has been sent. **/
+    paymentId: string;
+};
+
+declare enum WebhookEventType {
+    /**
+     * This is an enum value that represents values that could be added in the future.
+     * Clients should support unknown values as more of them could be added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    PAYMENT_FINISHED = "PAYMENT_FINISHED",
+    NODE_STATUS = "NODE_STATUS"
+}
+
+/** The transaction on the Bitcoin blockchain to withdraw funds from the Lightspark node to a Bitcoin wallet. **/
+type Withdrawal = OnChainTransaction & Transaction & Entity & {
+    /**
+     * The unique identifier of this entity across all Lightspark systems. Should be treated as an opaque
+     * string.
+     **/
+    id: string;
+    /** The date and time when this transaction was initiated. **/
+    createdAt: string;
+    /** The date and time when the entity was last updated. **/
+    updatedAt: string;
+    /** The current status of this transaction. **/
+    status: TransactionStatus;
+    /** The amount of money involved in this transaction. **/
+    amount: CurrencyAmount;
+    /**
+     * The height of the block that included this transaction. This will be zero for unconfirmed
+     * transactions.
+     **/
+    blockHeight: number;
+    /** The Bitcoin blockchain addresses this transaction was sent to. **/
+    destinationAddresses: string[];
+    /** The Lightspark node this withdrawal originated from. **/
+    originId: string;
+    /** The typename of the object **/
+    typename: string;
+    /** The date and time when this transaction was completed or failed. **/
+    resolvedAt?: string;
+    /** The hash of this transaction, so it can be uniquely identified on the Lightning Network. **/
+    transactionHash?: string;
+    /**
+     * The fees that were paid by the wallet sending the transaction to commit it to the Bitcoin
+     * blockchain.
+     **/
+    fees?: CurrencyAmount;
+    /**
+     * The hash of the block that included this transaction. This will be null for unconfirmed
+     * transactions.
+     **/
+    blockHash?: string;
+    /** The number of blockchain confirmations for this transaction in real time. **/
+    numConfirmations?: number;
+};
+declare const getWithdrawalQuery: (id: string) => Query<Withdrawal>;
+
+export { LightsparkNode as $, Account as A, BitcoinNetwork as B, Channel as C, DeleteApiTokenInput as D, Entity as E, FeeEstimate as F, FundNodeInput as G, FundNodeOutput as H, GraphNode as I, Hop as J, getHopQuery as K, LightsparkClient as L, HtlcAttemptFailureCode as M, IncomingPayment as N, IncomingPaymentAttempt as O, getIncomingPaymentAttemptQuery as P, IncomingPaymentAttemptStatus as Q, IncomingPaymentToAttemptsConnection as R, Invoice as S, getInvoiceQuery as T, InvoiceData as U, InvoiceType as V, LightningFeeEstimateForInvoiceInput as W, LightningFeeEstimateForNodeInput as X, LightningFeeEstimateOutput as Y, LightningTransaction as Z, getLightningTransactionQuery as _, AccountToApiTokensConnection as a, LightsparkNodePurpose as a0, LightsparkNodeStatus as a1, LightsparkNodeToChannelsConnection as a2, Node as a3, NodeAddress as a4, NodeAddressType as a5, NodeToAddressesConnection as a6, OnChainTransaction as a7, getOnChainTransactionQuery as a8, OutgoingPayment as a9, TransactionType as aA, TransactionUpdate as aB, WalletDashboard as aC, WebhookEventType as aD, Withdrawal as aE, getWithdrawalQuery as aF, WithdrawalMode as aG, WithdrawalRequest as aH, WithdrawalRequestStatus as aI, WithdrawalRequestToChannelClosingTransactionsConnection as aJ, WithdrawalRequestToChannelOpeningTransactionsConnection as aK, OutgoingPaymentAttempt as aa, OutgoingPaymentAttemptStatus as ab, OutgoingPaymentAttemptToHopsConnection as ac, OutgoingPaymentToAttemptsConnection as ad, PageInfo as ae, PayInvoiceInput as af, PayInvoiceOutput as ag, PaymentFailureReason as ah, PaymentRequest as ai, getPaymentRequestQuery as aj, PaymentRequestData as ak, PaymentRequestStatus as al, Permission as am, RequestWithdrawalInput as an, RequestWithdrawalOutput as ao, RichText as ap, RoutingTransaction as aq, getRoutingTransactionQuery as ar, RoutingTransactionFailureReason as as, Secret as at, SendPaymentInput as au, SendPaymentOutput as av, Transaction as aw, getTransactionQuery as ax, TransactionFailures as ay, TransactionStatus as az, AccountToChannelsConnection as b, AccountToNodesConnection as c, AccountToPaymentRequestsConnection as d, AccountToTransactionsConnection as e, ApiToken as f, getApiTokenQuery as g, BlockchainBalance as h, ChannelClosingTransaction as i, getChannelClosingTransactionQuery as j, ChannelFees as k, ChannelOpeningTransaction as l, getChannelOpeningTransactionQuery as m, ChannelStatus as n, ChannelToTransactionsConnection as o, CreateApiTokenInput as p, CreateApiTokenOutput as q, CreateInvoiceInput as r, CreateInvoiceOutput as s, CreateNodeWalletAddressInput as t, CreateNodeWalletAddressOutput as u, CurrencyAmount as v, CurrencyUnit as w, DeleteApiTokenOutput as x, Deposit as y, getDepositQuery as z };