@lightprotocol/stateless.js 0.22.1-alpha.0 → 0.22.1-alpha.2

package/dist/es/browser/rpc-interface.d.ts

@@ -0,0 +1,2873 @@
+import { PublicKey, MemcmpFilter, DataSlice, Commitment, GetAccountInfoConfig, AccountInfo, ConfirmedSignatureInfo, SignaturesForAddressOptions, TokenAmount } from '@solana/web3.js';
+import { Struct } from 'superstruct';
+import { BN254, ValidityProof, CompressedAccountWithMerkleContext, MerkleContextWithMerkleProof, TokenData, TreeInfo, AddressTreeInfo, CompressedProof, MerkleContext } from './state';
+import BN from 'bn.js';
+export interface LatestNonVotingSignatures {
+    context: {
+        slot: number;
+    };
+    value: {
+        items: {
+            signature: string;
+            slot: number;
+            blockTime: number;
+            error: string | null;
+        }[];
+    };
+}
+export interface GetCompressedAccountsByOwnerConfig {
+    filters?: GetCompressedAccountsFilter[];
+    dataSlice?: DataSlice;
+    cursor?: string;
+    limit?: BN;
+}
+export interface CompressedMintTokenHolders {
+    balance: BN;
+    owner: PublicKey;
+}
+export interface LatestNonVotingSignaturesPaginated {
+    context: {
+        slot: number;
+    };
+    value: {
+        items: {
+            signature: string;
+            slot: number;
+            blockTime: number;
+        }[];
+        cursor: string | null;
+    };
+}
+export interface SignatureWithMetadata {
+    blockTime: number;
+    signature: string;
+    slot: number;
+}
+/**
+ * Account hash and associated state tree info.
+ */
+export interface HashWithTreeInfo {
+    /**
+     * Account hash.
+     */
+    hash: BN254;
+    /**
+     * State tree info.
+     */
+    stateTreeInfo: TreeInfo;
+}
+/**
+ * Address and associated address tree info.
+ */
+export interface AddressWithTreeInfo {
+    /**
+     * Address.
+     */
+    address: BN254;
+    /**
+     * Address tree info.
+     */
+    addressTreeInfo: AddressTreeInfo;
+}
+export interface HashWithTree {
+    hash: BN254;
+    tree: PublicKey;
+    queue: PublicKey;
+}
+export interface AddressWithTree {
+    address: BN254;
+    tree: PublicKey;
+    queue: PublicKey;
+}
+export interface AddressWithTreeInfo {
+    address: BN254;
+    treeInfo: AddressTreeInfo;
+}
+export interface AddressWithTreeInfoV2 {
+    address: Uint8Array;
+    treeInfo: TreeInfo;
+}
+export declare enum DerivationMode {
+    compressible = "compressible",
+    standard = "standard"
+}
+export interface CompressedTransaction {
+    compressionInfo: {
+        closedAccounts: {
+            account: CompressedAccountWithMerkleContext;
+            maybeTokenData: TokenData | null;
+        }[];
+        openedAccounts: {
+            account: CompressedAccountWithMerkleContext;
+            maybeTokenData: TokenData | null;
+        }[];
+        preTokenBalances?: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+        }[];
+        postTokenBalances?: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+        }[];
+    };
+    transaction: any;
+}
+export interface HexBatchInputsForProver {
+    'input-compressed-accounts': HexInputsForProver[];
+}
+export interface HexInputsForProver {
+    root: string;
+    pathIndex: number;
+    pathElements: string[];
+    leaf: string;
+}
+/**
+ * Validity proof with context.
+ *
+ * You can request proofs via `rpc.getValidityProof` or
+ * `rpc.getValidityProofV0`.
+ */
+export type ValidityProofWithContext = {
+    /**
+     * Validity proof.
+     */
+    compressedProof: ValidityProof | null;
+    /**
+     * Roots.
+     */
+    roots: BN[];
+    /**
+     * Root indices.
+     */
+    rootIndices: number[];
+    /**
+     * Leaf indices.
+     */
+    leafIndices: number[];
+    /**
+     * Leaves.
+     */
+    leaves: BN[];
+    /**
+     * Tree infos.
+     */
+    treeInfos: TreeInfo[];
+    /**
+     * Whether to prove by indices.
+     */
+    proveByIndices: boolean[];
+};
+/**
+ * @deprecated use {@link ValidityProofWithContext} instead
+ */
+export type CompressedProofWithContext = {
+    compressedProof: CompressedProof;
+    roots: BN[];
+    rootIndices: number[];
+    leafIndices: number[];
+    leaves: BN[];
+    merkleTrees: PublicKey[];
+    nullifierQueues: PublicKey[];
+};
+export interface GetCompressedTokenAccountsByOwnerOrDelegateOptions {
+    mint?: PublicKey;
+    cursor?: string;
+    limit?: BN;
+}
+export type TokenBalance = {
+    balance: BN;
+    mint: PublicKey;
+};
+/**
+ * **Cursor** is a unique identifier for a page of results by which the next page can be fetched.
+ *
+ * **Limit** is the maximum number of results to return per page.
+ */
+export interface PaginatedOptions {
+    cursor?: string;
+    limit?: BN;
+}
+/**
+ * Note, DataSizeFilter is currently not available.
+ */
+export type GetCompressedAccountsFilter = MemcmpFilter;
+export type GetCompressedAccountConfig = {
+    encoding?: string;
+};
+export type GetCompressedAccountsConfig = {
+    dataSlice: DataSlice;
+    filters?: GetCompressedAccountsFilter[];
+};
+export interface ParsedTokenAccount {
+    compressedAccount: CompressedAccountWithMerkleContext;
+    parsed: TokenData;
+}
+export type WithContext<T> = {
+    /** context */
+    context: {
+        slot: number;
+    };
+    /** response value */
+    value: T;
+};
+export type WithCursor<T> = {
+    /** context */
+    cursor: string | null;
+    /** response value */
+    items: T;
+};
+/**
+ * @internal
+ */
+export declare function createRpcResult<T, U>(result: Struct<T, U>): Struct<RpcResult<T>, null>;
+/**
+ * @internal
+ */
+export declare function jsonRpcResult<T, U>(schema: Struct<T, U>): Struct<RpcResult<T>, null>;
+export type WithRpcContext<T> = {
+    context: {
+        slot: number;
+    };
+    value: T;
+};
+/**
+ * @internal
+ */
+export declare function jsonRpcResultAndContext<T, U>(value: Struct<T, U>): Struct<RpcResult<WithRpcContext<T>>, null>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountResult: Struct<{
+    data: {
+        data: string;
+        discriminator: BN;
+        dataHash: BN;
+    } | null;
+    lamports: BN;
+    owner: PublicKey;
+    address: number[] | null;
+    leafIndex: number;
+    seq: BN | null;
+    tree: PublicKey;
+    hash: BN;
+    slotCreated: BN;
+}, {
+    address: Struct<number[] | null, null>;
+    hash: Struct<BN, null>;
+    data: Struct<{
+        data: string;
+        discriminator: BN;
+        dataHash: BN;
+    } | null, {
+        data: Struct<string, null>;
+        dataHash: Struct<BN, null>;
+        discriminator: Struct<BN, null>;
+    }>;
+    lamports: Struct<BN, null>;
+    owner: Struct<PublicKey, null>;
+    leafIndex: Struct<number, null>;
+    tree: Struct<PublicKey, null>;
+    seq: Struct<BN | null, null>;
+    slotCreated: Struct<BN, null>;
+}>;
+export declare const CompressedAccountResultV2: Struct<{
+    data: {
+        data: string;
+        discriminator: BN;
+        dataHash: BN;
+    } | null;
+    lamports: BN;
+    owner: PublicKey;
+    address: number[] | null;
+    merkleContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+    leafIndex: number;
+    proveByIndex: boolean;
+    seq: BN | null;
+    hash: BN;
+    slotCreated: BN;
+}, {
+    address: Struct<number[] | null, null>;
+    hash: Struct<BN, null>;
+    data: Struct<{
+        data: string;
+        discriminator: BN;
+        dataHash: BN;
+    } | null, {
+        data: Struct<string, null>;
+        dataHash: Struct<BN, null>;
+        discriminator: Struct<BN, null>;
+    }>;
+    lamports: Struct<BN, null>;
+    owner: Struct<PublicKey, null>;
+    leafIndex: Struct<number, null>;
+    seq: Struct<BN | null, null>;
+    slotCreated: Struct<BN, null>;
+    merkleContext: Struct<{
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    }, {
+        treeType: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        queue: Struct<PublicKey, null>;
+        cpiContext: Struct<PublicKey | null, null>;
+        nextTreeContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+        }>;
+    }>;
+    proveByIndex: Struct<boolean, null>;
+}>;
+export declare const TokenDataResult: Struct<{
+    owner: PublicKey;
+    mint: PublicKey;
+    amount: BN;
+    delegate: PublicKey | null;
+    state: string;
+}, {
+    mint: Struct<PublicKey, null>;
+    owner: Struct<PublicKey, null>;
+    amount: Struct<BN, null>;
+    delegate: Struct<PublicKey | null, null>;
+    state: Struct<string, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountResult: Struct<{
+    tokenData: {
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    };
+    account: {
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    };
+}, {
+    tokenData: Struct<{
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    }, {
+        mint: Struct<PublicKey, null>;
+        owner: Struct<PublicKey, null>;
+        amount: Struct<BN, null>;
+        delegate: Struct<PublicKey | null, null>;
+        state: Struct<string, null>;
+    }>;
+    account: Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountResultV2: Struct<{
+    tokenData: {
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    };
+    account: {
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    };
+}, {
+    tokenData: Struct<{
+        owner: PublicKey;
+        mint: PublicKey;
+        amount: BN;
+        delegate: PublicKey | null;
+        state: string;
+    }, {
+        mint: Struct<PublicKey, null>;
+        owner: Struct<PublicKey, null>;
+        amount: Struct<BN, null>;
+        delegate: Struct<PublicKey | null, null>;
+        state: Struct<string, null>;
+    }>;
+    account: Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        proveByIndex: Struct<boolean, null>;
+    }>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleCompressedAccountsResult: Struct<{
+    items: {
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }[];
+}, {
+    items: Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }[], Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleCompressedAccountsResultV2: Struct<{
+    items: {
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[];
+}, {
+    items: Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[], Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        proveByIndex: Struct<boolean, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountsByOwnerResult: Struct<{
+    items: {
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }[], Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        leafIndex: number;
+        seq: BN | null;
+        tree: PublicKey;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedAccountsByOwnerResultV2: Struct<{
+    items: {
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }[], Struct<{
+        data: {
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null;
+        lamports: BN;
+        owner: PublicKey;
+        address: number[] | null;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        leafIndex: number;
+        proveByIndex: boolean;
+        seq: BN | null;
+        hash: BN;
+        slotCreated: BN;
+    }, {
+        address: Struct<number[] | null, null>;
+        hash: Struct<BN, null>;
+        data: Struct<{
+            data: string;
+            discriminator: BN;
+            dataHash: BN;
+        } | null, {
+            data: Struct<string, null>;
+            dataHash: Struct<BN, null>;
+            discriminator: Struct<BN, null>;
+        }>;
+        lamports: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+        leafIndex: Struct<number, null>;
+        seq: Struct<BN | null, null>;
+        slotCreated: Struct<BN, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        proveByIndex: Struct<boolean, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountsByOwnerOrDelegateResult: Struct<{
+    items: {
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            leafIndex: number;
+            seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            leafIndex: number;
+            seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }[], Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            leafIndex: number;
+            seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }, {
+        tokenData: Struct<{
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        }, {
+            mint: Struct<PublicKey, null>;
+            owner: Struct<PublicKey, null>;
+            amount: Struct<BN, null>;
+            delegate: Struct<PublicKey | null, null>;
+            state: Struct<string, null>;
+        }>;
+        account: Struct<{
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            leafIndex: number;
+            seq: BN | null;
+            tree: PublicKey;
+            hash: BN;
+            slotCreated: BN;
+        }, {
+            address: Struct<number[] | null, null>;
+            hash: Struct<BN, null>;
+            data: Struct<{
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null, {
+                data: Struct<string, null>;
+                dataHash: Struct<BN, null>;
+                discriminator: Struct<BN, null>;
+            }>;
+            lamports: Struct<BN, null>;
+            owner: Struct<PublicKey, null>;
+            leafIndex: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            seq: Struct<BN | null, null>;
+            slotCreated: Struct<BN, null>;
+        }>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTokenAccountsByOwnerOrDelegateResultV2: Struct<{
+    items: {
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }[], Struct<{
+        tokenData: {
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        };
+        account: {
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
+            hash: BN;
+            slotCreated: BN;
+        };
+    }, {
+        tokenData: Struct<{
+            owner: PublicKey;
+            mint: PublicKey;
+            amount: BN;
+            delegate: PublicKey | null;
+            state: string;
+        }, {
+            mint: Struct<PublicKey, null>;
+            owner: Struct<PublicKey, null>;
+            amount: Struct<BN, null>;
+            delegate: Struct<PublicKey | null, null>;
+            state: Struct<string, null>;
+        }>;
+        account: Struct<{
+            data: {
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null;
+            lamports: BN;
+            owner: PublicKey;
+            address: number[] | null;
+            merkleContext: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            };
+            leafIndex: number;
+            proveByIndex: boolean;
+            seq: BN | null;
+            hash: BN;
+            slotCreated: BN;
+        }, {
+            address: Struct<number[] | null, null>;
+            hash: Struct<BN, null>;
+            data: Struct<{
+                data: string;
+                discriminator: BN;
+                dataHash: BN;
+            } | null, {
+                data: Struct<string, null>;
+                dataHash: Struct<BN, null>;
+                discriminator: Struct<BN, null>;
+            }>;
+            lamports: Struct<BN, null>;
+            owner: Struct<PublicKey, null>;
+            leafIndex: Struct<number, null>;
+            seq: Struct<BN | null, null>;
+            slotCreated: Struct<BN, null>;
+            merkleContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+                nextTreeContext?: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined;
+            }, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+                nextTreeContext: Struct<{
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                } | null | undefined, {
+                    treeType: Struct<number, null>;
+                    tree: Struct<PublicKey, null>;
+                    queue: Struct<PublicKey, null>;
+                    cpiContext: Struct<PublicKey | null, null>;
+                }>;
+            }>;
+            proveByIndex: Struct<boolean, null>;
+        }>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const SlotResult: Struct<number, null>;
+/**
+ * @internal
+ */
+export declare const HealthResult: Struct<string, null>;
+/**
+ * @internal
+ */
+export declare const LatestNonVotingSignaturesResult: Struct<{
+    items: {
+        error: string | null;
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[];
+}, {
+    items: Struct<{
+        error: string | null;
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[], Struct<{
+        error: string | null;
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }, {
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+        blockTime: Struct<number, null>;
+        error: Struct<string | null, null>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const LatestNonVotingSignaturesResultPaginated: Struct<{
+    items: {
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[], Struct<{
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }, {
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+        blockTime: Struct<number, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const MerkleProofResult: Struct<{
+    root: BN;
+    proof: BN[];
+    leafIndex: number;
+    hash: BN;
+    merkleTree: PublicKey;
+    rootSeq: number;
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const MerkleProofResultV2: Struct<{
+    root: BN;
+    proof: BN[];
+    leafIndex: number;
+    proveByIndex: boolean;
+    hash: BN;
+    rootSeq: number;
+    treeContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    root: Struct<BN, null>;
+    rootSeq: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+    treeContext: Struct<{
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    }, {
+        treeType: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        queue: Struct<PublicKey, null>;
+        cpiContext: Struct<PublicKey | null, null>;
+        nextTreeContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+        }>;
+    }>;
+}>;
+/**
+ * @internal
+ */
+export declare const NewAddressProofResult: Struct<{
+    root: BN;
+    proof: BN[];
+    address: BN;
+    merkleTree: PublicKey;
+    rootSeq: number;
+    nextIndex: number;
+    lowerRangeAddress: BN;
+    higherRangeAddress: BN;
+    lowElementLeafIndex: number;
+}, {
+    address: Struct<BN, null>;
+    nextIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+    lowerRangeAddress: Struct<BN, null>;
+    higherRangeAddress: Struct<BN, null>;
+    lowElementLeafIndex: Struct<number, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const RootIndexResultV2: Struct<{
+    rootIndex: number;
+    proveByIndex: boolean;
+}, {
+    rootIndex: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const ValidityProofResult: Struct<{
+    compressedProof: {
+        a: number[];
+        c: number[];
+        b: number[];
+    };
+    leafIndices: number[];
+    leaves: BN[];
+    rootIndices: number[];
+    roots: BN[];
+    merkleTrees: PublicKey[];
+}, {
+    compressedProof: Struct<{
+        a: number[];
+        c: number[];
+        b: number[];
+    }, {
+        a: Struct<number[], Struct<number, null>>;
+        b: Struct<number[], Struct<number, null>>;
+        c: Struct<number[], Struct<number, null>>;
+    }>;
+    leafIndices: Struct<number[], Struct<number, null>>;
+    leaves: Struct<BN[], Struct<BN, null>>;
+    rootIndices: Struct<number[], Struct<number, null>>;
+    roots: Struct<BN[], Struct<BN, null>>;
+    merkleTrees: Struct<PublicKey[], Struct<PublicKey, null>>;
+}>;
+export declare const ValidityProofResultV2: Struct<{
+    accounts: {
+        root: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            rootIndex: number;
+            proveByIndex: boolean;
+        };
+        leafIndex: number;
+        hash: BN;
+    }[];
+    compressedProof: {
+        a: number[];
+        c: number[];
+        b: number[];
+    } | null;
+    addresses: {
+        root: BN;
+        address: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: number;
+    }[];
+}, {
+    compressedProof: Struct<{
+        a: number[];
+        c: number[];
+        b: number[];
+    } | null, {
+        a: Struct<number[], Struct<number, null>>;
+        b: Struct<number[], Struct<number, null>>;
+        c: Struct<number[], Struct<number, null>>;
+    }>;
+    accounts: Struct<{
+        root: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            rootIndex: number;
+            proveByIndex: boolean;
+        };
+        leafIndex: number;
+        hash: BN;
+    }[], Struct<{
+        root: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: {
+            rootIndex: number;
+            proveByIndex: boolean;
+        };
+        leafIndex: number;
+        hash: BN;
+    }, {
+        hash: Struct<BN, null>;
+        root: Struct<BN, null>;
+        rootIndex: Struct<{
+            rootIndex: number;
+            proveByIndex: boolean;
+        }, {
+            rootIndex: Struct<number, null>;
+            proveByIndex: Struct<boolean, null>;
+        }>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+        leafIndex: Struct<number, null>;
+    }>>;
+    addresses: Struct<{
+        root: BN;
+        address: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: number;
+    }[], Struct<{
+        root: BN;
+        address: BN;
+        merkleContext: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        };
+        rootIndex: number;
+    }, {
+        address: Struct<BN, null>;
+        root: Struct<BN, null>;
+        rootIndex: Struct<number, null>;
+        merkleContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+            nextTreeContext?: {
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined;
+        }, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+            nextTreeContext: Struct<{
+                cpiContext: PublicKey | null;
+                tree: PublicKey;
+                queue: PublicKey;
+                treeType: number;
+            } | null | undefined, {
+                treeType: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                queue: Struct<PublicKey, null>;
+                cpiContext: Struct<PublicKey | null, null>;
+            }>;
+        }>;
+    }>>;
+}>;
+/**
+ * @internal
+ */
+export declare const MultipleMerkleProofsResult: Struct<{
+    root: BN;
+    proof: BN[];
+    leafIndex: number;
+    hash: BN;
+    merkleTree: PublicKey;
+    rootSeq: number;
+}[], Struct<{
+    root: BN;
+    proof: BN[];
+    leafIndex: number;
+    hash: BN;
+    merkleTree: PublicKey;
+    rootSeq: number;
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    merkleTree: Struct<PublicKey, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    rootSeq: Struct<number, null>;
+    root: Struct<BN, null>;
+}>>;
+/**
+ * @internal
+ */
+export declare const MultipleMerkleProofsResultV2: Struct<{
+    root: BN;
+    proof: BN[];
+    leafIndex: number;
+    proveByIndex: boolean;
+    hash: BN;
+    rootSeq: number;
+    treeContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+}[], Struct<{
+    root: BN;
+    proof: BN[];
+    leafIndex: number;
+    proveByIndex: boolean;
+    hash: BN;
+    rootSeq: number;
+    treeContext: {
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    };
+}, {
+    hash: Struct<BN, null>;
+    leafIndex: Struct<number, null>;
+    proof: Struct<BN[], Struct<BN, null>>;
+    root: Struct<BN, null>;
+    rootSeq: Struct<number, null>;
+    proveByIndex: Struct<boolean, null>;
+    treeContext: Struct<{
+        cpiContext: PublicKey | null;
+        tree: PublicKey;
+        queue: PublicKey;
+        treeType: number;
+        nextTreeContext?: {
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined;
+    }, {
+        treeType: Struct<number, null>;
+        tree: Struct<PublicKey, null>;
+        queue: Struct<PublicKey, null>;
+        cpiContext: Struct<PublicKey | null, null>;
+        nextTreeContext: Struct<{
+            cpiContext: PublicKey | null;
+            tree: PublicKey;
+            queue: PublicKey;
+            treeType: number;
+        } | null | undefined, {
+            treeType: Struct<number, null>;
+            tree: Struct<PublicKey, null>;
+            queue: Struct<PublicKey, null>;
+            cpiContext: Struct<PublicKey | null, null>;
+        }>;
+    }>;
+}>>;
+/**
+ * @internal
+ */
+export declare const BalanceResult: Struct<{
+    amount: BN;
+}, {
+    amount: Struct<BN, null>;
+}>;
+export declare const NativeBalanceResult: Struct<BN, null>;
+export declare const TokenBalanceResult: Struct<{
+    mint: PublicKey;
+    balance: BN;
+}, {
+    balance: Struct<BN, null>;
+    mint: Struct<PublicKey, null>;
+}>;
+export declare const TokenBalanceListResult: Struct<{
+    cursor: string | null;
+    tokenBalances: {
+        mint: PublicKey;
+        balance: BN;
+    }[];
+}, {
+    tokenBalances: Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }[], Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }, {
+        balance: Struct<BN, null>;
+        mint: Struct<PublicKey, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+export declare const TokenBalanceListResultV2: Struct<{
+    items: {
+        mint: PublicKey;
+        balance: BN;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }[], Struct<{
+        mint: PublicKey;
+        balance: BN;
+    }, {
+        balance: Struct<BN, null>;
+        mint: Struct<PublicKey, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+export declare const CompressedMintTokenHoldersResult: Struct<{
+    items: {
+        owner: PublicKey;
+        balance: BN;
+    }[];
+    cursor: string | null;
+}, {
+    cursor: Struct<string | null, null>;
+    items: Struct<{
+        owner: PublicKey;
+        balance: BN;
+    }[], Struct<{
+        owner: PublicKey;
+        balance: BN;
+    }, {
+        balance: Struct<BN, null>;
+        owner: Struct<PublicKey, null>;
+    }>>;
+}>;
+export declare const AccountProofResult: Struct<{
+    root: number[];
+    proof: number[][];
+    hash: number[];
+}, {
+    hash: Struct<number[], Struct<number, null>>;
+    root: Struct<number[], Struct<number, null>>;
+    proof: Struct<number[][], Struct<number[], Struct<number, null>>>;
+}>;
+export declare const toUnixTimestamp: (blockTime: string) => number;
+export declare const SignatureListResult: Struct<{
+    items: {
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[];
+}, {
+    items: Struct<{
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[], Struct<{
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }, {
+        blockTime: Struct<number, null>;
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+    }>>;
+}>;
+export declare const SignatureListWithCursorResult: Struct<{
+    items: {
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[];
+    cursor: string | null;
+}, {
+    items: Struct<{
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }[], Struct<{
+        blockTime: number;
+        signature: string;
+        slot: number;
+    }, {
+        blockTime: Struct<number, null>;
+        signature: Struct<string, null>;
+        slot: Struct<number, null>;
+    }>>;
+    cursor: Struct<string | null, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTransactionResult: Struct<{
+    compressionInfo: {
+        closedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    };
+    transaction?: any;
+}, {
+    compressionInfo: Struct<{
+        closedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    }, {
+        closedAccounts: Struct<{
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null, {
+                    data: Struct<string, null>;
+                    dataHash: Struct<BN, null>;
+                    discriminator: Struct<BN, null>;
+                }>;
+                lamports: Struct<BN, null>;
+                owner: Struct<PublicKey, null>;
+                leafIndex: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                seq: Struct<BN | null, null>;
+                slotCreated: Struct<BN, null>;
+            }>;
+            optionalTokenData: Struct<{
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null, {
+                mint: Struct<PublicKey, null>;
+                owner: Struct<PublicKey, null>;
+                amount: Struct<BN, null>;
+                delegate: Struct<PublicKey | null, null>;
+                state: Struct<string, null>;
+            }>;
+        }>>;
+        openedAccounts: Struct<{
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                leafIndex: number;
+                seq: BN | null;
+                tree: PublicKey;
+                hash: BN;
+                slotCreated: BN;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null, {
+                    data: Struct<string, null>;
+                    dataHash: Struct<BN, null>;
+                    discriminator: Struct<BN, null>;
+                }>;
+                lamports: Struct<BN, null>;
+                owner: Struct<PublicKey, null>;
+                leafIndex: Struct<number, null>;
+                tree: Struct<PublicKey, null>;
+                seq: Struct<BN | null, null>;
+                slotCreated: Struct<BN, null>;
+            }>;
+            optionalTokenData: Struct<{
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null, {
+                mint: Struct<PublicKey, null>;
+                owner: Struct<PublicKey, null>;
+                amount: Struct<BN, null>;
+                delegate: Struct<PublicKey | null, null>;
+                state: Struct<string, null>;
+            }>;
+        }>>;
+    }>;
+    transaction: Struct<any, null>;
+}>;
+/**
+ * @internal
+ */
+export declare const CompressedTransactionResultV2: Struct<{
+    compressionInfo: {
+        closedAccounts: {
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    lamports: BN;
+                    owner: PublicKey;
+                    address: number[] | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    };
+    transaction?: any;
+}, {
+    compressionInfo: Struct<{
+        closedAccounts: {
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    lamports: BN;
+                    owner: PublicKey;
+                    address: number[] | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+        openedAccounts: {
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[];
+    }, {
+        closedAccounts: Struct<{
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    lamports: BN;
+                    owner: PublicKey;
+                    address: number[] | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                account: {
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    lamports: BN;
+                    owner: PublicKey;
+                    address: number[] | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                account: {
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    lamports: BN;
+                    owner: PublicKey;
+                    address: number[] | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                };
+                txHash: BN;
+                nullifier: BN;
+            }, {
+                account: Struct<{
+                    data: {
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null;
+                    lamports: BN;
+                    owner: PublicKey;
+                    address: number[] | null;
+                    merkleContext: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    };
+                    leafIndex: number;
+                    proveByIndex: boolean;
+                    seq: BN | null;
+                    hash: BN;
+                    slotCreated: BN;
+                }, {
+                    address: Struct<number[] | null, null>;
+                    hash: Struct<BN, null>;
+                    data: Struct<{
+                        data: string;
+                        discriminator: BN;
+                        dataHash: BN;
+                    } | null, {
+                        data: Struct<string, null>;
+                        dataHash: Struct<BN, null>;
+                        discriminator: Struct<BN, null>;
+                    }>;
+                    lamports: Struct<BN, null>;
+                    owner: Struct<PublicKey, null>;
+                    leafIndex: Struct<number, null>;
+                    seq: Struct<BN | null, null>;
+                    slotCreated: Struct<BN, null>;
+                    merkleContext: Struct<{
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                        nextTreeContext?: {
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined;
+                    }, {
+                        treeType: Struct<number, null>;
+                        tree: Struct<PublicKey, null>;
+                        queue: Struct<PublicKey, null>;
+                        cpiContext: Struct<PublicKey | null, null>;
+                        nextTreeContext: Struct<{
+                            cpiContext: PublicKey | null;
+                            tree: PublicKey;
+                            queue: PublicKey;
+                            treeType: number;
+                        } | null | undefined, {
+                            treeType: Struct<number, null>;
+                            tree: Struct<PublicKey, null>;
+                            queue: Struct<PublicKey, null>;
+                            cpiContext: Struct<PublicKey | null, null>;
+                        }>;
+                    }>;
+                    proveByIndex: Struct<boolean, null>;
+                }>;
+                txHash: Struct<BN, null>;
+                nullifier: Struct<BN, null>;
+            }>;
+            optionalTokenData: Struct<{
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null, {
+                mint: Struct<PublicKey, null>;
+                owner: Struct<PublicKey, null>;
+                amount: Struct<BN, null>;
+                delegate: Struct<PublicKey | null, null>;
+                state: Struct<string, null>;
+            }>;
+        }>>;
+        openedAccounts: Struct<{
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }[], Struct<{
+            account: {
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            };
+            optionalTokenData: {
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null;
+        }, {
+            account: Struct<{
+                data: {
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null;
+                lamports: BN;
+                owner: PublicKey;
+                address: number[] | null;
+                merkleContext: {
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                };
+                leafIndex: number;
+                proveByIndex: boolean;
+                seq: BN | null;
+                hash: BN;
+                slotCreated: BN;
+            }, {
+                address: Struct<number[] | null, null>;
+                hash: Struct<BN, null>;
+                data: Struct<{
+                    data: string;
+                    discriminator: BN;
+                    dataHash: BN;
+                } | null, {
+                    data: Struct<string, null>;
+                    dataHash: Struct<BN, null>;
+                    discriminator: Struct<BN, null>;
+                }>;
+                lamports: Struct<BN, null>;
+                owner: Struct<PublicKey, null>;
+                leafIndex: Struct<number, null>;
+                seq: Struct<BN | null, null>;
+                slotCreated: Struct<BN, null>;
+                merkleContext: Struct<{
+                    cpiContext: PublicKey | null;
+                    tree: PublicKey;
+                    queue: PublicKey;
+                    treeType: number;
+                    nextTreeContext?: {
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined;
+                }, {
+                    treeType: Struct<number, null>;
+                    tree: Struct<PublicKey, null>;
+                    queue: Struct<PublicKey, null>;
+                    cpiContext: Struct<PublicKey | null, null>;
+                    nextTreeContext: Struct<{
+                        cpiContext: PublicKey | null;
+                        tree: PublicKey;
+                        queue: PublicKey;
+                        treeType: number;
+                    } | null | undefined, {
+                        treeType: Struct<number, null>;
+                        tree: Struct<PublicKey, null>;
+                        queue: Struct<PublicKey, null>;
+                        cpiContext: Struct<PublicKey | null, null>;
+                    }>;
+                }>;
+                proveByIndex: Struct<boolean, null>;
+            }>;
+            optionalTokenData: Struct<{
+                owner: PublicKey;
+                mint: PublicKey;
+                amount: BN;
+                delegate: PublicKey | null;
+                state: string;
+            } | null, {
+                mint: Struct<PublicKey, null>;
+                owner: Struct<PublicKey, null>;
+                amount: Struct<BN, null>;
+                delegate: Struct<PublicKey | null, null>;
+                state: Struct<string, null>;
+            }>;
+        }>>;
+    }>;
+    transaction: Struct<any, null>;
+}>;
+export interface CompressionApiInterface {
+    getCompressedAccount(address?: BN254, hash?: BN254): Promise<CompressedAccountWithMerkleContext | null>;
+    getCompressedBalance(address?: BN254, hash?: BN254): Promise<BN | null>;
+    getCompressedBalanceByOwner(owner: PublicKey): Promise<BN>;
+    getCompressedAccountProof(hash: BN254): Promise<MerkleContextWithMerkleProof>;
+    getMultipleCompressedAccounts(hashes: BN254[]): Promise<CompressedAccountWithMerkleContext[]>;
+    getMultipleCompressedAccountProofs(hashes: BN254[]): Promise<MerkleContextWithMerkleProof[]>;
+    getValidityProof(hashes: BN254[], newAddresses: BN254[]): Promise<ValidityProofWithContext>;
+    getValidityProofV0(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<ValidityProofWithContext>;
+    getValidityProofAndRpcContext(hashes: HashWithTree[], newAddresses: AddressWithTree[]): Promise<WithContext<ValidityProofWithContext>>;
+    getCompressedAccountsByOwner(owner: PublicKey, config?: GetCompressedAccountsByOwnerConfig): Promise<WithCursor<CompressedAccountWithMerkleContext[]>>;
+    getCompressedMintTokenHolders(mint: PublicKey, options?: PaginatedOptions): Promise<WithContext<WithCursor<CompressedMintTokenHolders[]>>>;
+    getCompressedTokenAccountsByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
+    getCompressedTokenAccountsByDelegate(delegate: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<ParsedTokenAccount[]>>;
+    getCompressedTokenAccountBalance(hash: BN254): Promise<{
+        amount: BN;
+    }>;
+    getCompressedTokenBalancesByOwner(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithCursor<TokenBalance[]>>;
+    getCompressedTokenBalancesByOwnerV2(publicKey: PublicKey, options: GetCompressedTokenAccountsByOwnerOrDelegateOptions): Promise<WithContext<WithCursor<TokenBalance[]>>>;
+    getTransactionWithCompressionInfo(signature: string): Promise<CompressedTransaction | null>;
+    getCompressionSignaturesForAccount(hash: BN254): Promise<SignatureWithMetadata[]>;
+    getCompressionSignaturesForAddress(address: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getCompressionSignaturesForTokenOwner(owner: PublicKey, options?: PaginatedOptions): Promise<WithCursor<SignatureWithMetadata[]>>;
+    getLatestNonVotingSignatures(limit?: number, cursor?: string): Promise<LatestNonVotingSignatures>;
+    getLatestCompressionSignatures(cursor?: string, limit?: number): Promise<LatestNonVotingSignaturesPaginated>;
+    getIndexerHealth(): Promise<string>;
+    getIndexerSlot(): Promise<number>;
+    getAccountInfoInterface(address: PublicKey, programId: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig, addressSpace?: TreeInfo): Promise<{
+        accountInfo: AccountInfo<Buffer>;
+        isCold: boolean;
+        loadContext?: MerkleContext;
+    } | null>;
+    getSignaturesForAddressInterface(address: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    getSignaturesForOwnerInterface(owner: PublicKey, options?: SignaturesForAddressOptions, compressedOptions?: PaginatedOptions): Promise<SignaturesForAddressInterfaceResult>;
+    getTokenAccountBalanceInterface(address: PublicKey, owner: PublicKey, mint: PublicKey, commitment?: Commitment): Promise<UnifiedTokenBalance>;
+    getBalanceInterface(address: PublicKey, commitment?: Commitment): Promise<UnifiedBalance>;
+}
+export type RpcResultSuccess<T> = {
+    jsonrpc: '2.0';
+    id: string;
+    result: T;
+};
+export type RpcResultError = {
+    jsonrpc: '2.0';
+    id: string;
+    error: {
+        code: unknown;
+        message: string;
+        data?: any;
+    };
+};
+export type RpcResult<T> = RpcResultSuccess<T> | RpcResultError;
+/**
+ * Source type for signature data.
+ */
+export declare const SignatureSource: {
+    /** From standard Solana RPC (getSignaturesForAddress) */
+    readonly Solana: "solana";
+    /** From compression indexer (getCompressionSignaturesFor*) */
+    readonly Compressed: "compressed";
+};
+export type SignatureSourceType = (typeof SignatureSource)[keyof typeof SignatureSource];
+/**
+ * Unified signature info combining data from both Solana RPC and compression indexer.
+ *
+ * Design rationale:
+ * - `sources` array indicates where this signature was found (can be both!)
+ * - Primary data comes from Solana RPC when available (richer: err, memo, confirmationStatus)
+ * - Compression-only signatures still included for complete transaction history
+ */
+export interface UnifiedSignatureInfo {
+    /** Transaction signature (base58) */
+    signature: string;
+    /** Slot when the transaction was processed */
+    slot: number;
+    /** Block time (unix timestamp), null if not available */
+    blockTime: number | null;
+    /** Transaction error, null if successful. Only from Solana RPC. */
+    err: any | null;
+    /** Memo data. Only from Solana RPC. */
+    memo: string | null;
+    /** Confirmation status. Only from Solana RPC. */
+    confirmationStatus?: string;
+    /**
+     * Sources where this signature was found.
+     * - ['solana'] = only in Solana RPC
+     * - ['compressed'] = only in compression indexer
+     * - ['solana', 'compressed'] = found in both (compression tx indexed by both)
+     */
+    sources: SignatureSourceType[];
+}
+/**
+ * Result of getSignaturesForAddressInterface / getSignaturesForOwnerInterface.
+ *
+ * Design rationale:
+ * - `signatures`: Unified view, merged and deduplicated, sorted by slot desc
+ * - `solana` / `compressed`: Raw responses preserved for clients that need source-specific data
+ * - Allows callers to use the unified view OR drill into specific sources
+ */
+export interface SignaturesForAddressInterfaceResult {
+    /** Merged signatures from all sources, sorted by slot (descending) */
+    signatures: UnifiedSignatureInfo[];
+    /** Raw signatures from Solana RPC */
+    solana: ConfirmedSignatureInfo[];
+    /** Raw signatures from compression indexer */
+    compressed: SignatureWithMetadata[];
+}
+/**
+ * Unified token balance combining hot and cold token balances.
+ */
+export interface UnifiedTokenBalance {
+    /** Total balance (hot + cold) */
+    amount: BN;
+    /** True if any cold balance exists - call load() before usage */
+    hasColdBalance: boolean;
+    /** Token decimals (from on-chain mint or 0 if unknown) */
+    decimals: number;
+    /** Raw Solana RPC TokenAmount response, null if no on-chain account */
+    solana: TokenAmount | null;
+}
+/**
+ * Unified SOL balance combining hot and cold SOL balances.
+ */
+export interface UnifiedBalance {
+    /** Total balance (hot + cold) in lamports */
+    total: BN;
+    /** True if any cold balance exists - call load() before usage */
+    hasColdBalance: boolean;
+}