@berachain/berajs 0.1.0-alpha.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,1703 @@
+import * as swr from 'swr';
+import { SWRResponse } from 'swr';
+import { G as GetConvertToAssetsProps, O as OnChainPool, c as GetHoneyVaultsBalanceResponse, e as IsBadCollateralResponse, f as GetBgtAprSimulationArgs, h as GetBgtAprSimulationResult, k as GlobalData, m as GetMarkets, S as StakedBeraWithdrawal, R as RewardVaultIncentive, q as GetRewardVaultRewardsReturn, s as GetGaugeData, u as GetStakedBeraSnapshotsArgs, x as GetUserVaultsResponse, z as GetVaultHistoryArgs, V as ValidatorRewardAllocation, B as ValidatorWithUserBoost, D as UserBoostsOnValidator, F as UserStakingPoolPosition, J as ValidatorQueuedCommission, L as ValidatorQueuedOperatorAddress } from '../getValidatorQueuedOperatorAddress-DK2Xv19c.js';
+import { D as DefaultHookOptions, S as SwapReferrer, d as HoneyConfigContextReturn, I as IRawAggregatorQuote, A as Aggregators, a as Token, x as TokenInput, y as PoolCreationStep, k as TokenCurrentPriceMap, z as TokenWithAmount, E as DefaultHookReturnType, F as IUserPosition, l as AllowanceToken, G as BalanceTokenWithMetadata, B as BalanceToken, j as PythPriceFeedMap, P as PythLatestUpdates, b as TokenWithMetadata, J as TokenPriceInfo, K as IUseContractWriteArgs, U as UseContractWriteApi } from '../dex-DreiokgL.js';
+export { L as TxnEventKeys } from '../dex-DreiokgL.js';
+import { Address, Hex } from 'viem';
+import * as _berachain_graphql_dex_api from '@berachain/graphql/dex/api';
+import { GetPoolsQueryVariables, MinimalPoolFragment, GqlPoolEventType, PoolHistoricalDataFragment, GqlRewardVaultDynamicData, GqlValidatorDynamicData } from '@berachain/graphql/dex/api';
+export { u as useBexStatus } from '../BexStatusProvider-nS3NcdxI.js';
+import { PoolType } from '@berachain-foundation/berancer-sdk';
+import { SubgraphPoolFragment } from '@berachain/graphql/dex/subgraph';
+import { P as POLLING } from '../polling-BKnyavLI.js';
+import * as swr__internal from 'swr/_internal';
+import { GetZapTransactions, GetZapTransactionResponse } from '../types/index.js';
+import * as _ensofinance_sdk from '@ensofinance/sdk';
+export { BundleData } from '@ensofinance/sdk';
+import * as react from 'react';
+import react__default from 'react';
+import { G as GovernanceTopic, c as CustomProposalErrors, C as CustomProposal, U as UserVaultInfo, B as BribeBoostRewardProof } from '../staking-Cggi38So.js';
+import * as swr_infinite from 'swr/infinite';
+import { SWRInfiniteResponse, SWRInfiniteKeyLoader } from 'swr/infinite';
+import * as _berachain_graphql_governance from '@berachain/graphql/governance';
+import { Proposal_Filter, Proposal_OrderBy, OrderDirection, ProposalStatus, ProposalSelectionFragment, ProposalWithVotesFragment, GetProposalVotesQueryVariables } from '@berachain/graphql/governance';
+import { I as IHoneySwapState } from '../useHoneySwapState-Ci8_c2bT.js';
+export { r as reducer, u as useHoneySwapState } from '../useHoneySwapState-Ci8_c2bT.js';
+import * as _berachain_graphql_honey from '@berachain/graphql/honey';
+import BigNumber from 'bignumber.js';
+import * as _berachain_graphql_pol_api from '@berachain/graphql/pol/api';
+import { GqlRewardVaultFilter, ApiVaultFragment, GetVaultsQueryVariables, GetSWberaVaultSnapshotsQuery, GetVaultHistoryQuery, ApiValidatorFragment, GetValidatorsQueryVariables, GqlChain, GetValidatorsQuery, GetValidatorQuery, ApiValidatorMinimalFragment } from '@berachain/graphql/pol/api';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Config } from '@wagmi/core';
+import { T as TransactionActionType } from '../txnEnum-BQKDfaeH.js';
+import * as _berachain_graphql_pol_subgraph from '@berachain/graphql/pol/subgraph';
+import { GetValidatorBlockStatsQuery, GetValidatorAnalyticsQuery } from '@berachain/graphql/pol/subgraph';
+import '../aggregatorsRouter-Cny4B_MB.js';
+import '@berachain/config';
+import '../BeraError-CfcNTfpH.js';
+import '@sentry/nextjs';
+import '@berachain/config/internal/edge-config';
+
+declare const useGetConvertToAssets: ({ sharesAmount, vaultAddress, vaultChainId, }: Omit<GetConvertToAssetsProps, "publicClient"> & {
+    vaultChainId?: number;
+}, options?: DefaultHookOptions) => {
+    refresh: () => void;
+    data: {
+        raw: bigint;
+        formatted: string;
+    } | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<{
+        raw: bigint;
+        formatted: string;
+    }>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+type IUseAggregatorsQuotesArgs = BeraJS.BaseFunctionArgs & {
+    tokenIn: Address;
+    tokenOut: Address;
+    tokenInDecimals: number;
+    tokenOutDecimals: number;
+    amount: string;
+    slippage: number;
+    referrer?: SwapReferrer;
+    rewardVault?: Address;
+    /**
+     * Useful cause the collaterals are provided byt he honeyContext and this way we can
+     * use the Provider only in the swap page where is needed.
+     *
+     * The collaterals for the honey mint/redeem aggregator.
+     */
+    honeyNativeState?: Pick<HoneyConfigContextReturn, "collateralList" | "protocol">;
+};
+declare const USE_AGGREGATORS_QUOTES_QUERY_KEY = "useAggregatorsQuotes";
+declare const useAggregatorsQuotes: (args: IUseAggregatorsQuotesArgs, options?: DefaultHookOptions) => {
+    refresh: () => Promise<IRawAggregatorQuote<false> | IRawAggregatorQuote | undefined>[];
+    quotes: IRawAggregatorQuote[];
+    loadingAggregatorsNames: (Aggregators | null)[];
+    isLoading: boolean;
+    error: any;
+};
+
+declare const useAggregatorsRouterFeeBps: () => {
+    refresh: swr.KeyedMutator<number>;
+    data: number | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<number>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useAllUserPoolsQueryKey: ({ query, }?: {
+    query?: GetPoolsQueryVariables;
+}) => (string | _berachain_graphql_dex_api.Exact<{
+    textSearch?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["String"]["input"]>;
+    first?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["Int"]["input"]>;
+    userAddress?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["String"]["input"]>;
+    chain: Array<_berachain_graphql_dex_api.GqlChain> | _berachain_graphql_dex_api.GqlChain;
+    orderBy?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.GqlPoolOrderBy>;
+    skip?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["Int"]["input"]>;
+    orderDirection?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.GqlPoolOrderDirection>;
+    blacklistedPoolIds?: _berachain_graphql_dex_api.InputMaybe<Array<_berachain_graphql_dex_api.Scalars["String"]["input"]> | _berachain_graphql_dex_api.Scalars["String"]["input"]>;
+}> | undefined)[];
+declare const useAllUserPools: (query: GetPoolsQueryVariables, options?: DefaultHookOptions) => {
+    refresh: () => void;
+    data: {
+        pools: {
+            __typename?: "GqlPoolMinimal";
+            id: string;
+            name: string;
+            address: `0x${string}`;
+            factory?: `0x${string}` | null;
+            protocolVersion: number;
+            type: _berachain_graphql_dex_api.GqlPoolType;
+            tokens: Array<{
+                __typename?: "GqlPoolTokenExpanded";
+                address: `0x${string}`;
+                symbol: string;
+                name: string;
+                decimals: number;
+            }>;
+            dynamicData: {
+                __typename?: "GqlPoolDynamicData";
+                totalShares: string;
+                fees24h: string;
+                volume24h: string;
+                swapFee: string;
+                isInRecoveryMode: boolean;
+                isPaused: boolean;
+                totalLiquidity: string;
+                aprItems: Array<{
+                    __typename?: "GqlPoolAprItem";
+                    apr: number;
+                    type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+                    id: string;
+                }>;
+            };
+            userBalance?: {
+                __typename?: "GqlPoolUserBalance";
+                totalBalanceUsd: number;
+                walletBalance: any;
+                walletBalanceUsd: number;
+            } | null;
+            rewardVault?: {
+                __typename?: "GqlRewardVault";
+                isVaultWhitelisted: boolean;
+                vaultAddress: `0x${string}`;
+                stakingTokenAddress: `0x${string}`;
+                dynamicData?: {
+                    __typename?: "GqlRewardVaultDynamicData";
+                    activeIncentivesValueUsd: string;
+                    apr?: number | null;
+                    bgtCapturePercentage: string;
+                    allTimeReceivedBGTAmount: string;
+                } | null;
+            } | null;
+        }[];
+        count: number;
+    } | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<{
+        pools: {
+            __typename?: "GqlPoolMinimal";
+            id: string;
+            name: string;
+            address: `0x${string}`;
+            factory?: `0x${string}` | null;
+            protocolVersion: number;
+            type: _berachain_graphql_dex_api.GqlPoolType;
+            tokens: Array<{
+                __typename?: "GqlPoolTokenExpanded";
+                address: `0x${string}`;
+                symbol: string;
+                name: string;
+                decimals: number;
+            }>;
+            dynamicData: {
+                __typename?: "GqlPoolDynamicData";
+                totalShares: string;
+                fees24h: string;
+                volume24h: string;
+                swapFee: string;
+                isInRecoveryMode: boolean;
+                isPaused: boolean;
+                totalLiquidity: string;
+                aprItems: Array<{
+                    __typename?: "GqlPoolAprItem";
+                    apr: number;
+                    type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+                    id: string;
+                }>;
+            };
+            userBalance?: {
+                __typename?: "GqlPoolUserBalance";
+                totalBalanceUsd: number;
+                walletBalance: any;
+                walletBalanceUsd: number;
+            } | null;
+            rewardVault?: {
+                __typename?: "GqlRewardVault";
+                isVaultWhitelisted: boolean;
+                vaultAddress: `0x${string}`;
+                stakingTokenAddress: `0x${string}`;
+                dynamicData?: {
+                    __typename?: "GqlRewardVaultDynamicData";
+                    activeIncentivesValueUsd: string;
+                    apr?: number | null;
+                    bgtCapturePercentage: string;
+                    allTimeReceivedBGTAmount: string;
+                } | null;
+            } | null;
+        }[];
+        count: number;
+    }>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useApiPoolQueryKey: ({ poolId, account, }: {
+    poolId: Hex;
+    account?: Address;
+}) => readonly ["usePool-api", `0x${string}`, `0x${string}` | undefined] | null;
+declare function useApiPool({ poolId, account, }: {
+    poolId: Hex;
+    account?: Address;
+}): {
+    refresh: () => void;
+    data: MinimalPoolFragment | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<MinimalPoolFragment>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+interface UseCreatePoolProps extends BeraJS.BaseFunctionArgs {
+    poolCreateTokens: Token[];
+    initialLiquidityTokens: TokenInput[];
+    normalizedWeights: bigint[];
+    poolType: PoolType;
+    swapFee: number;
+    owner: string;
+    poolSymbol: string;
+    poolName: string;
+    amplification: number;
+    weightsDuplicationThreshold?: number;
+    oracles: Oracle[];
+}
+interface UseCreatePoolReturn {
+    generatedPoolName: string;
+    generatedPoolSymbol: string;
+    isDupePool: boolean;
+    dupePool?: SubgraphPoolFragment | null;
+    createPoolArgs: any;
+    isLoadingPools: boolean;
+    errorLoadingPools: boolean;
+}
+declare enum OracleMode {
+    None = "None",
+    Custom = "Custom"
+}
+interface Oracle {
+    mode: OracleMode;
+    address: string;
+    tokenAddress: string;
+    cacheDuration: number;
+}
+declare const useCreatePool: ({ poolCreateTokens, initialLiquidityTokens, normalizedWeights, poolType, poolName, poolSymbol, swapFee, owner, amplification, oracles, weightsDuplicationThreshold, ...baseArgs }: UseCreatePoolProps) => UseCreatePoolReturn;
+
+declare const useExploitedTokensQueryKey: (tokens: Token[] | undefined) => readonly ["useExploitedTokens", Token[]] | null;
+/**
+ * This hook checks if any of provided tokens might have been exploited by frontrunning its deployment.
+ *
+ * @see {@link getIsTokenExploited} for more details
+ * @returns a record of tokens and whether they might have been exploited
+ */
+declare const useExploitedTokens: ({ tokens, }: {
+    tokens: Token[] | undefined;
+}) => {
+    refresh: () => Promise<Record<`0x${string}`, boolean> | undefined>;
+    data: Record<`0x${string}`, boolean> | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<Record<`0x${string}`, boolean>>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useGlobalLiquidityAndSwapVolume: () => {
+    data: {
+        totalLiquidity: number;
+        swapVolume24h: number;
+    };
+    refresh: () => Promise<_berachain_graphql_dex_api.GetGlobalLiquidityAndSwapVolumeQuery | undefined>;
+    error: any;
+    mutate: swr.KeyedMutator<_berachain_graphql_dex_api.GetGlobalLiquidityAndSwapVolumeQuery>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+type LiquidityMismatchInfo = {
+    title: string | null;
+    message: string | null;
+    suggestWeighted?: boolean;
+};
+interface UseLiquidityMismatchParams {
+    currentStep: PoolCreationStep;
+    tokenPrices?: TokenCurrentPriceMap;
+    isLoadingTokenPrices: boolean;
+    tokens: TokenWithAmount[] | null;
+    weights: bigint[] | null;
+    weightsError: string | null;
+    poolType: PoolType;
+    liquidityMismatchTolerancePercent?: number;
+    oracles: Oracle[];
+}
+/**
+ * Hook for detecting liquidity mismatches.
+ *
+ * @param {PoolCreationStep} currentStep - The current step of the pool creation process.
+ * @param {Record<string, number>} tokenPrices - The current token prices.
+ * @param {boolean} isLoadingTokenPrices - Whether the token prices are still loading.
+ * @param {Array<{ address: string, amount: number }>} tokens - The tokens in the pool, including their addresses and amounts.
+ * @param {Record<string, number>} weights - The per-token weights in the pool we are creating.
+ * @param {string | null} weightsError - An error message for the weights indicating that the weights are invalid.
+ * @param {string} poolType - The type of pool being created.
+ * @param {number} liquidityMismatchTolerancePercent - The tolerance for liquidity mismatches in percent.
+ * @returns {Object} The liquidity mismatch info.
+ */
+declare const useLiquidityMismatch: ({ currentStep, tokenPrices, isLoadingTokenPrices, tokens, weights, weightsError, poolType, liquidityMismatchTolerancePercent, oracles, }: UseLiquidityMismatchParams) => LiquidityMismatchInfo;
+
+type IUseLpPositionArgs = {
+    pool: MinimalPoolFragment | undefined;
+    vaultAddress?: Address | undefined;
+};
+/**
+ * Given a pool and used within an initialized viem context, returns the user's position
+ */
+declare const useLpPosition: ({ pool, vaultAddress }: IUseLpPositionArgs, options?: DefaultHookOptions) => DefaultHookReturnType<IUserPosition>;
+
+type NeedsApprovalToken = AllowanceToken & {
+    maxAmountIn: bigint;
+};
+declare const useMultipleTokenApprovalsWithSlippage: (tokenInput: TokenInput[], spender: Address | undefined, slippage?: number) => {
+    needsApproval: NeedsApprovalToken[];
+    refresh: () => void;
+    isLoading: boolean;
+};
+
+declare function useOnChainPoolDataQueryKey(args: {
+    poolId: string;
+} | {
+    address: Address;
+}): readonly ["useOnChainPoolData", `0x${string}`] | null;
+interface OnChainPoolFragment extends SubgraphPoolFragment {
+    amplificationParameter: {
+        currentFormattedValue: number | undefined;
+    } | undefined;
+}
+declare function useOnChainPoolData(poolId: string): {
+    data: OnChainPoolFragment | undefined;
+    error: any;
+    isLoading: boolean;
+    mutate: swr.KeyedMutator<OnChainPool>;
+    refresh: () => Promise<OnChainPool | undefined>;
+};
+
+/**
+ * Hook for fetching relayer approval status with SWR
+ *
+ * @returns SWR data spread and refresh function
+ */
+declare const usePollPoolCreationRelayerApproval: (options?: DefaultHookOptions) => {
+    refreshPoolCreationApproval: () => void;
+    data: boolean | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<boolean>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare function useSubgraphPoolQueryKey({ poolId }: {
+    poolId: string;
+}): string[] | null;
+declare const usePool: ({ poolId }: {
+    poolId: Hex;
+}) => {
+    data: readonly [{
+        __typename?: "Pool";
+        id: string;
+        name?: string | null;
+        address: `0x${string}`;
+        factory?: `0x${string}` | null;
+        swapFee: string;
+        totalShares: string;
+        totalLiquidity: string;
+        createTime: number;
+        owner?: `0x${string}` | null;
+        type?: string | null;
+        tokens?: Array<{
+            __typename?: "PoolToken";
+            address: `0x${string}`;
+            name: string;
+            decimals: number;
+            symbol: string;
+            index?: number | null;
+            weight?: string | null;
+            balance: string;
+        }> | null;
+    } | undefined, _berachain_graphql_dex_api.MinimalPoolFragment | undefined, OnChainPoolFragment | undefined];
+    isLoading: boolean;
+    isError: any;
+    refresh: () => void;
+};
+
+declare const usePoolEvents: ({ poolId, typeInArray, }: {
+    poolId: string | undefined;
+    typeInArray: GqlPoolEventType[];
+}) => swr.SWRResponse<_berachain_graphql_dex_api.GetPoolEventsQuery, any, {
+    refreshInterval: POLLING;
+}>;
+
+type UsePoolHistoricalDataArgs = {
+    poolId: string | undefined;
+};
+declare const usePoolHistoricalData: ({ poolId, ...baseArgs }: UsePoolHistoricalDataArgs & BeraJS.BaseFunctionArgs, options?: DefaultHookOptions) => DefaultHookReturnType<PoolHistoricalDataFragment[] | undefined>;
+
+declare const usePoolsQueryKey: ({ query, }?: {
+    query?: GetPoolsQueryVariables;
+}) => (string | _berachain_graphql_dex_api.Exact<{
+    textSearch?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["String"]["input"]>;
+    first?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["Int"]["input"]>;
+    userAddress?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["String"]["input"]>;
+    chain: Array<_berachain_graphql_dex_api.GqlChain> | _berachain_graphql_dex_api.GqlChain;
+    orderBy?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.GqlPoolOrderBy>;
+    skip?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.Scalars["Int"]["input"]>;
+    orderDirection?: _berachain_graphql_dex_api.InputMaybe<_berachain_graphql_dex_api.GqlPoolOrderDirection>;
+    blacklistedPoolIds?: _berachain_graphql_dex_api.InputMaybe<Array<_berachain_graphql_dex_api.Scalars["String"]["input"]> | _berachain_graphql_dex_api.Scalars["String"]["input"]>;
+}> | undefined)[];
+/**
+ * Returns all pools from bex api, including user's pools if logged in
+ * @todo add subgraph fallback
+ */
+declare const usePools: (query: GetPoolsQueryVariables, options?: DefaultHookOptions) => {
+    pools: {
+        __typename?: "GqlPoolMinimal";
+        id: string;
+        name: string;
+        address: `0x${string}`;
+        factory?: `0x${string}` | null;
+        protocolVersion: number;
+        type: _berachain_graphql_dex_api.GqlPoolType;
+        tokens: Array<{
+            __typename?: "GqlPoolTokenExpanded";
+            address: `0x${string}`;
+            symbol: string;
+            name: string;
+            decimals: number;
+        }>;
+        dynamicData: {
+            __typename?: "GqlPoolDynamicData";
+            totalShares: string;
+            fees24h: string;
+            volume24h: string;
+            swapFee: string;
+            isInRecoveryMode: boolean;
+            isPaused: boolean;
+            totalLiquidity: string;
+            aprItems: Array<{
+                __typename?: "GqlPoolAprItem";
+                apr: number;
+                type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+                id: string;
+            }>;
+        };
+        userBalance?: {
+            __typename?: "GqlPoolUserBalance";
+            totalBalanceUsd: number;
+            walletBalance: any;
+            walletBalanceUsd: number;
+        } | null;
+        rewardVault?: {
+            __typename?: "GqlRewardVault";
+            isVaultWhitelisted: boolean;
+            vaultAddress: `0x${string}`;
+            stakingTokenAddress: `0x${string}`;
+            dynamicData?: {
+                __typename?: "GqlRewardVaultDynamicData";
+                activeIncentivesValueUsd: string;
+                apr?: number | null;
+                bgtCapturePercentage: string;
+                allTimeReceivedBGTAmount: string;
+            } | null;
+        } | null;
+    }[];
+    walletPools: {
+        __typename?: "GqlPoolMinimal";
+        id: string;
+        name: string;
+        address: `0x${string}`;
+        factory?: `0x${string}` | null;
+        protocolVersion: number;
+        type: _berachain_graphql_dex_api.GqlPoolType;
+        tokens: Array<{
+            __typename?: "GqlPoolTokenExpanded";
+            address: `0x${string}`;
+            symbol: string;
+            name: string;
+            decimals: number;
+        }>;
+        dynamicData: {
+            __typename?: "GqlPoolDynamicData";
+            totalShares: string;
+            fees24h: string;
+            volume24h: string;
+            swapFee: string;
+            isInRecoveryMode: boolean;
+            isPaused: boolean;
+            totalLiquidity: string;
+            aprItems: Array<{
+                __typename?: "GqlPoolAprItem";
+                apr: number;
+                type: _berachain_graphql_dex_api.GqlPoolAprItemType;
+                id: string;
+            }>;
+        };
+        userBalance?: {
+            __typename?: "GqlPoolUserBalance";
+            totalBalanceUsd: number;
+            walletBalance: any;
+            walletBalanceUsd: number;
+        } | null;
+        rewardVault?: {
+            __typename?: "GqlRewardVault";
+            isVaultWhitelisted: boolean;
+            vaultAddress: `0x${string}`;
+            stakingTokenAddress: `0x${string}`;
+            dynamicData?: {
+                __typename?: "GqlRewardVaultDynamicData";
+                activeIncentivesValueUsd: string;
+                apr?: number | null;
+                bgtCapturePercentage: string;
+                allTimeReceivedBGTAmount: string;
+            } | null;
+        } | null;
+    }[];
+    isLoading: boolean;
+    refresh: () => void;
+    pagination: {
+        page: number;
+        pageSize: _berachain_graphql_dex_api.InputMaybe<number> | undefined;
+        count: number;
+    };
+};
+
+type UseBendTransactionRequestsArgs = {
+    tokenIn?: Pick<BalanceTokenWithMetadata, "address" | "decimals" | "price" | "formattedBalance" | "chainId">;
+    loanTokenAddress: Address;
+    loanTokenPrice: number | undefined;
+    bendVault: Address;
+    rewardVault?: Address;
+    amount?: string;
+    slippage?: number;
+    chainId?: number;
+};
+/**
+ * Get the bend transaction requests for swapping tokens using Enso.
+ * @param {UseBendTransactionRequestsArgs} props - The props for the hook see {@link UseBendTransactionRequestsArgs}
+ * @returns {DefaultHookReturnType<GetZapTransactionResponse> & {tokens: BalanceTokenWithMetadata[], refresh: () => void}}
+ *
+ * The bend transaction response data with polling enabled, see {@link GetZapTransactionResponse} and {@link BalanceTokenWithMetadata}
+ * @remarks The hook is only enabled when all parameters are provided and amount is greater than 0
+ * @see {@link useEnsoZap}
+ */
+declare function useBendTransactionRequests({ tokenIn, loanTokenAddress, loanTokenPrice, bendVault, rewardVault, amount, slippage, chainId, }: UseBendTransactionRequestsArgs, options?: DefaultHookOptions): {
+    nativeFee: bigint;
+    error: any;
+    tokens: BalanceTokenWithMetadata[] | undefined;
+    refresh: () => void;
+    data: {
+        bundle: _ensofinance_sdk.BundleData;
+        transactions: GetZapTransactions;
+        supplyAmount: {
+            raw: bigint;
+            formatted: string;
+        };
+        priceImpact: number | undefined;
+    } | undefined;
+    mutate: swr.KeyedMutator<{
+        bundle: _ensofinance_sdk.BundleData;
+        transactions: GetZapTransactions;
+        supplyAmount: {
+            raw: bigint;
+            formatted: string;
+        };
+        priceImpact: number | undefined;
+    }>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+declare function useBendTransactionRequestsHelper({ tokenIn, loanTokenAddress, loanTokenPrice, bendVault, rewardVault, amount, slippage, chainId, }: UseBendTransactionRequestsArgs, options?: DefaultHookOptions): swr.SWRResponse<{
+    bundle: _ensofinance_sdk.BundleData;
+    transactions: GetZapTransactions;
+    supplyAmount: {
+        raw: bigint;
+        formatted: string;
+    };
+    priceImpact: number | undefined;
+}, any, {
+    refreshInterval: POLLING;
+    errorRetryInterval?: number | undefined;
+    errorRetryCount?: number;
+    loadingTimeout?: number | undefined;
+    focusThrottleInterval?: number | undefined;
+    dedupingInterval?: number | undefined;
+    refreshWhenHidden?: boolean;
+    refreshWhenOffline?: boolean;
+    revalidateOnFocus?: boolean | undefined;
+    revalidateOnReconnect?: boolean | undefined;
+    revalidateOnMount?: boolean;
+    revalidateIfStale?: boolean | undefined;
+    shouldRetryOnError?: boolean | ((err: any) => boolean) | undefined;
+    keepPreviousData?: boolean;
+    suspense?: boolean;
+    fallbackData?: any;
+    fetcher?: swr.BareFetcher<any> | undefined;
+    use?: swr.Middleware[];
+    fallback?: {
+        [key: string]: any;
+    } | undefined;
+    isPaused?: (() => boolean) | undefined;
+    onLoadingSlow?: ((key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>) => void) | undefined;
+    onSuccess?: ((data: any, key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>) => void) | undefined;
+    onError?: ((err: any, key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>) => void) | undefined;
+    onErrorRetry?: ((err: any, key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>, revalidate: swr.Revalidator, revalidateOpts: Required<swr.RevalidatorOptions>) => void) | undefined;
+    onDiscarded?: ((key: string) => void) | undefined;
+    compare?: ((a: any, b: any) => boolean) | undefined;
+    isOnline?: (() => boolean) | undefined;
+    isVisible?: (() => boolean) | undefined;
+    initFocus?: ((callback: () => void) => (() => void) | void) | undefined;
+    initReconnect?: ((callback: () => void) => (() => void) | void) | undefined;
+    provider?: (cache: Readonly<swr.Cache>) => swr.Cache;
+    isEnabled?: boolean;
+}>;
+
+/**
+ * Get the enso client.
+ * @returns {EnsoClient} The enso client, see {@link EnsoClient}
+ * @see {@link useEnsoBalances}
+ * @see {@link useTokens}
+ */
+declare function useEnsoZap({ chainId }: {
+    chainId?: number;
+}): {
+    tokens: BalanceTokenWithMetadata[] | undefined;
+    getBendTransactionRequests: ({ tokenIn, amount, loanToken, bendVault, rewardVault, slippage, }: {
+        tokenIn?: Pick<BalanceToken, "address" | "decimals" | "chainId">;
+        amount: string;
+        loanToken: Address;
+        bendVault: Address;
+        rewardVault?: Address;
+        slippage: number;
+    }) => Promise<GetZapTransactionResponse>;
+    getZapTransactionRequests: ({ tokenIn, tokenOut, amount, slippage, }: {
+        tokenIn?: Pick<BalanceToken, "address" | "decimals" | "chainId">;
+        tokenOut: Address;
+        amount: string;
+        slippage: number;
+    }) => Promise<GetZapTransactionResponse>;
+    refreshTokens: () => Promise<BalanceTokenWithMetadata[] | undefined>;
+};
+
+/**
+ * Get the zap transaction requests for swapping tokens using Enso.
+ * @param {Pick<BalanceToken, "address" | "decimals">} tokenIn - The input token to swap from
+ * @param {Pick<BalanceToken, "address" | "decimals">} tokenOut - The output token to swap to
+ * @param {string} amount - The amount of input token to swap
+ * @param {number} slippage - The slippage tolerance to use for the route in percentage
+ * @returns {DefaultHookReturnType<GetZapTransactionResponse> & {tokens: BalanceTokenWithMetadata[], refresh: () => void}}
+ *
+ * The zap transaction response data with polling enabled, see {@link GetZapTransactionResponse} and {@link BalanceTokenWithMetadata}
+ * @remarks The hook is only enabled when all parameters are provided and amount is greater than 0
+ * @see {@link useEnsoZap}
+ */
+declare const useZapTransactionRequests: ({ tokenIn, tokenOut, amount, slippage, chainId, }: {
+    tokenIn?: Pick<BalanceToken, "address" | "decimals">;
+    tokenOut?: Pick<BalanceToken, "address" | "decimals">;
+    amount?: string;
+    slippage?: number;
+    chainId?: number;
+}) => {
+    tokens: BalanceTokenWithMetadata[] | undefined;
+    refresh: () => void;
+    data: GetZapTransactionResponse | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<GetZapTransactionResponse>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useCreateProposal: ({ initialData, currentTopic, onError, }: {
+    initialData?: any;
+    currentTopic: GovernanceTopic;
+    onError: (e: CustomProposalErrors) => void;
+}) => {
+    proposal: CustomProposal;
+    setProposal: react.Dispatch<react.SetStateAction<CustomProposal>>;
+    addProposalAction: () => void;
+    removeProposalAction: (idx: number) => void;
+    computeParamsAndErrors: () => readonly [`0x${string}`[], bigint[], `0x${string}`[], string] | undefined;
+};
+
+/**
+ * Returns the amount of voting power that a wallet had when the voting period began.
+ * {@link https://docs.openzeppelin.com/contracts/5.x/api/governance#Votes-getPastVotes-address-uint256-}
+ */
+declare const useGetPastVotes: (args: {
+    wallet?: Address;
+} & ({
+    proposalId?: bigint;
+    timepoint: number | bigint;
+} | {
+    proposalId: bigint;
+    timepoint?: number | bigint;
+})) => swr.SWRResponse<string, any, any>;
+
+declare const useHasVoted: ({ proposalId, wallet, }: {
+    proposalId: string;
+    wallet?: Address;
+}) => swr.SWRResponse<boolean, any, any>;
+
+declare const useIsCanceller: ({ account, ...baseArgs }: {
+    account: Address | undefined;
+} & BeraJS.BaseFunctionArgs) => swr.SWRResponse<boolean, any, {
+    refreshInterval: POLLING;
+    revalidateOnFocus: false;
+}>;
+
+type UsePollAllProposalsArgs = {
+    topic: string;
+    where?: Proposal_Filter;
+    perPage?: number;
+    orderBy?: Proposal_OrderBy;
+    orderDirection?: OrderDirection;
+    status_in?: ProposalStatus[];
+    text?: string;
+    autoRefreshProposals?: boolean;
+};
+type ProposalResult = {
+    data: ProposalSelectionFragment[][];
+    hasMore: boolean;
+} & Omit<SWRInfiniteResponse<ProposalSelectionFragment[]>, "data">;
+type PollAllProposalsKey = [
+    "usePollAllProposals",
+    number,
+    string,
+    Proposal_Filter | undefined,
+    ProposalStatus[] | undefined,
+    Proposal_OrderBy | undefined,
+    OrderDirection | undefined,
+    number,
+    string | undefined
+] | null;
+declare function usePollAllProposalsQueryKey(topic: string, args?: Partial<UsePollAllProposalsArgs>): (pageIndex: number, previousPageData?: ProposalSelectionFragment[]) => PollAllProposalsKey;
+/**
+ * Fetch all proposals for a given topic
+ */
+declare function usePollAllProposals(args: UsePollAllProposalsArgs, options?: DefaultHookOptions & {
+    autoRefresh?: boolean;
+}): ProposalResult;
+
+interface UsePollProposalResponse extends DefaultHookReturnType<ProposalWithVotesFragment> {
+}
+/**
+ * Polls a proposal and returns the proposal details.
+ * Pulls data from the subgraph and onchain.
+ *
+ * @param proposalId - The ID of the proposal to poll
+ * @param options - Optional configuration options
+ * @param options.autoRefresh - If true, the data will be refreshed automatically based on the block number and status threshold
+ * @returns {UsePollProposalResponse} Object containing:
+ *   - data: ProposalWithVotesFragment | undefined - The proposal data if successful
+ *   - error: Error | undefined - Error object if request failed
+ *   - isLoading: boolean - True while data is being fetched
+ *   - isValidating: boolean - True while data is being revalidated
+ *   - mutate: () => Promise<ProposalWithVotesFragment | undefined> - Function to manually refresh the data
+ *   - refresh: () => Promise<void> - Function to manually refresh the data
+ */
+declare const usePollProposal: (proposalId: string, options?: DefaultHookOptions & {
+    autoRefresh?: boolean;
+}) => UsePollProposalResponse;
+
+declare const usePollProposalThreshold: (governorAddress: Address) => DefaultHookReturnType<{
+    votesThreshold: string;
+}>;
+
+type UsePollProposalVotesArgs = Omit<GetProposalVotesQueryVariables, "offset" | "limit">;
+/**
+ * Fetches all the votes for a proposal from the Subgraph
+ * @param args - The arguments to pass to the query
+ * @param total - The total amount of pages of votes to fetch
+ */
+declare const usePollProposalVotes: (args: UsePollProposalVotesArgs, total: number) => swr_infinite.SWRInfiniteResponse<{
+    data: _berachain_graphql_governance.GetProposalVotesQuery;
+}, any>;
+declare const usePollProposalVotesQueryKey: ({ ...args }: UsePollProposalVotesArgs, total: number) => SWRInfiniteKeyLoader;
+
+declare const usePollUserDelegates: (options?: DefaultHookOptions) => DefaultHookReturnType<{
+    delegate: Address;
+    currentVotes: string | undefined;
+}>;
+
+declare const useProposalFromTx: (txHash?: Address) => SWRResponse<ProposalWithVotesFragment | null>;
+
+/**
+ * Timepoint used to retrieve user’s votes and quorum. If using block
+ * number (as per Compound’s Comp), the snapshot is performed at
+ * the end of this block. Hence, voting for this proposal starts at the beginning of the following block.
+ *
+ * {@link https://docs.openzeppelin.com/contracts/5.x/api/governance#IGovernor-proposalSnapshot-uint256-}
+ */
+declare const useProposalSnapshot: ({ proposalId, }: {
+    proposalId: number | bigint | string | undefined;
+}) => SWRResponse<string>;
+
+declare const useProposalState: ({ proposalId, governorAddress, }: {
+    proposalId: number | bigint | string | undefined;
+    governorAddress: Address;
+}) => SWRResponse<string>;
+
+declare const TimelockOperationState: {
+    readonly 0: "unset";
+    readonly 1: "waiting";
+    readonly 2: "ready";
+    readonly 3: "done";
+};
+/**
+ * Fetches the state of a proposal timelock
+ * @returns state of the proposal timelock (unset, waiting, ready, done)
+ */
+declare const useProposalTimelockState: ({ proposalTimelockId, timelockAddress, }: {
+    proposalTimelockId: Address | undefined;
+    timelockAddress: Address;
+}) => SWRResponse<(typeof TimelockOperationState)[keyof typeof TimelockOperationState]>;
+
+/**
+ * Queries the quorum for a given timestamp.
+ *
+ * @returns current quorum if timestamp is in the future.
+ */
+declare function useQuorum({ at }: {
+    at: number | string;
+}, { isEnabled, }: {
+    isEnabled?: boolean;
+}): {
+    data: number | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<string>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+interface UseCappedGloballyResponse extends DefaultHookReturnType<boolean | undefined> {
+}
+declare const useCappedGlobally: ({ asset, amount, isMint, isBasketModeEnabled, }: {
+    asset: Token | undefined;
+    amount: string | undefined;
+    isMint: boolean;
+    isBasketModeEnabled: boolean | undefined;
+}, options?: DefaultHookOptions) => UseCappedGloballyResponse;
+
+interface UseCappedRelativelyResponse extends DefaultHookReturnType<boolean | undefined> {
+}
+declare const useCappedRelatively: ({ asset, amount, isMint, isBasketModeEnabled, }: {
+    asset: Address | undefined;
+    amount: string | undefined;
+    isMint: boolean;
+    isBasketModeEnabled: boolean | undefined;
+}, options?: DefaultHookOptions) => UseCappedRelativelyResponse;
+
+interface UseCollateralWeightsResponse extends DefaultHookReturnType<Record<Address, bigint> | undefined> {
+}
+declare const useCollateralWeights: ({ collateralList, }: {
+    collateralList: Token[] | undefined;
+}, options?: DefaultHookOptions) => UseCollateralWeightsResponse;
+
+/**
+ * Interface defining the state props that we need without the entire IHoneySwapState
+ */
+type HoneyAlertStateProps = Pick<IHoneySwapState, "actionType" | "fromAmount" | "toAmount" | "collaterals" | "isBasketModeEnabled">;
+/**
+ * Interface defining the alert states returned by the useHoneyAlerts hook
+ */
+interface HoneyAlertsReturn {
+    /** Indicates if the vault's liquidity is completely depleted (balance <= 1) */
+    isLiquidityDepleted: boolean;
+    isLiquidityDepletedCollaterals: Token[] | undefined;
+    /** Indicates if the requested redeem amount exceeds available liquidity in the vault*/
+    isRedeemMoreThanLiquidity: boolean;
+    isRedeemMoreThanLiquidityCollaterals: Token[] | undefined;
+    /** Indicates if the vault's liquidity is low (balance <= 1000) */
+    isLowLiquidity: boolean;
+    isLiquidityLowCollaterals: Token[] | undefined;
+    /** Indicates if the selected collateral is flagged as bad (blacklisted or depegged) */
+    isDepegged: boolean;
+    /** Indicates if the selected collateral is blacklisted */
+    isBlacklisted: boolean;
+    /** Indicates if the input amount exceeds the global cap limit */
+    isCappedGlobally: boolean | undefined;
+    /** Indicates if the input amount exceeds the relative cap limit */
+    isCappedRelatively: boolean | undefined;
+    /** Indicates if the input amount exceeds the balance of the user */
+    isExceedingBalance: boolean;
+}
+/**
+ * Hook that monitors various alert conditions for Honey swap operations
+ *
+ * This hook tracks multiple states that could affect swap operations:
+ * - Liquidity levels in vaults (depleted, low)
+ * - Collateral quality (blacklisted, depegged)
+ * - Cap limits for transactions (global, relative)
+ * - Balance checks
+ *
+ * @param {Object} params - The parameters object
+ * @param {HoneyAlertStateProps} params.state - The current state of the Honey swap operation
+ * @returns {HoneyAlertsReturn} Object containing various alert states
+
+ */
+declare const useHoneyAlerts: ({ actionType, collaterals, fromAmount, toAmount, isBasketModeEnabled, }: HoneyAlertStateProps) => HoneyAlertsReturn;
+
+/**
+ * Hook that fetches and maintains balances for HONEY token and collateral tokens
+ *
+ * This hook:
+ * - Fetches balances for all collateral tokens and the HONEY token
+ * - Updates balances at regular intervals (10s)
+ * - Returns a map of token addresses to their respective balances
+ * - Provides a refresh function to manually trigger balance updates
+ *
+ * The hook requires:
+ * - A connected wallet account
+ * - A public client
+ * - BeraJS configuration
+ * - A list of collateral tokens
+ *
+ * @returns {DefaultHookReturnType<Record<Address, BalanceToken>>} Object containing:
+ *   - data: Map of token addresses to their balances
+ *   - error: Any error that occurred during fetching
+ *   - isLoading: Loading state
+ *   - refresh: Function to manually refresh balances
+ */
+declare const useHoneyBalances: () => DefaultHookReturnType<Record<Address, BalanceToken>>;
+
+declare function useHoneyChartData({ days }: {
+    days: number;
+}): {
+    refresh: () => Promise<_berachain_graphql_honey.GetChartDataQuery | undefined>;
+    data: _berachain_graphql_honey.GetChartDataQuery | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<_berachain_graphql_honey.GetChartDataQuery>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare function useHoneyGlobalData(): {
+    data: {
+        dailyVolume: BigNumber | undefined;
+        __typename?: "Query";
+        honeySnapshots?: {
+            __typename?: "HoneySnapshot";
+            id: string;
+            allTimeVolume: string;
+            totalVolume: string;
+            timestamp: string;
+            totalSupply: string;
+            mintVolume: string;
+            redeemVolume: string;
+        }[] | undefined;
+    };
+    refresh: () => Promise<_berachain_graphql_honey.GetGlobalDataQuery | undefined>;
+    error: any;
+    mutate: swr.KeyedMutator<_berachain_graphql_honey.GetGlobalDataQuery>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useHoneyVaultsBalance: (options?: DefaultHookOptions) => DefaultHookReturnType<GetHoneyVaultsBalanceResponse[]>;
+
+interface UseIsBadCollateralResponse extends DefaultHookReturnType<IsBadCollateralResponse | undefined> {
+}
+declare const useIsBadCollateralAsset: ({ collateral }: {
+    collateral: Token | undefined;
+}, options?: DefaultHookOptions) => UseIsBadCollateralResponse;
+
+declare function useIsBasketModeEnabled({ state }: {
+    state: IHoneySwapState;
+}, options?: DefaultHookOptions): DefaultHookReturnType<boolean | undefined>;
+
+/**
+ * Hook to fetch the latest Pyth price updates for specified pair addresses
+ * @param {Object} params - The parameters object
+ * @param {Address[] | undefined} params.pairMainAddress - Array of pair addresses to fetch price updates for
+ * @returns {SWRResponse<PythLatestUpdates>} SWR response containing the latest Pyth price updates
+ * @example
+ * ```ts
+ * const { data, error } = usePythLatestPrices({
+ *   pairMainAddress: ["0x123...", "0x456..."]
+ * });
+ * ```
+ */
+declare function usePythLatestPrices({ priceFeedMap, }: {
+    priceFeedMap: PythPriceFeedMap | undefined;
+}, options?: DefaultHookOptions): SWRResponse<PythLatestUpdates>;
+
+declare const usePythUpdateFee: ({ pythPriceFeedCalldata, tokenListLength, }: {
+    pythPriceFeedCalldata: Address[] | undefined;
+    tokenListLength: number;
+}, options?: DefaultHookOptions) => {
+    QUERY_KEY: readonly ["usePythUpdateFee", `0x${string}`[]] | null;
+    data: bigint;
+    isLoading: boolean;
+};
+
+declare function useBgtAprSimulation(args: GetBgtAprSimulationArgs | undefined): GetBgtAprSimulationResult
+/**
+ * Returns undefined if still loading
+ */
+ | undefined;
+
+declare const useBgtUnstakedBalance: (options?: DefaultHookOptions) => DefaultHookReturnType<string | undefined>;
+
+declare const useClaimableFees: () => {
+    refresh: () => Promise<string | undefined>;
+    data: string | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<string>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+type UseEarnedStakedBeraVaultArgs = {
+    /**
+     * The token that the user has staked
+     */
+    receiptToken: TokenWithMetadata;
+};
+declare function useEarnedStakedBeraVault({ receiptToken }: UseEarnedStakedBeraVaultArgs, opt?: DefaultHookOptions): DefaultHookReturnType<string>;
+
+/**
+ * Hook that fetches and returns the highest APR (Annual Percentage Rate) from reward vaults.
+ *
+ * @param {`0x${string}`[]} [params.filteringVaults=[]] - Optional array of vault addresses to filter by
+ *
+ * @returns {Object} An object containing:
+ *   - highestApr: The highest APR value from the reward vaults
+ *   - refresh: Function to manually refresh the data
+ *   - ...swrResponse: All properties from the underlying SWR response
+ *
+ * @example
+ * const { highestApr } = useHighestVaultsAPR({
+ *   filteringVaults: ['0x123...', '0x456...']
+ * });
+ */
+declare const useHighestVaultsAPR: (where?: GqlRewardVaultFilter, { isEnabled }?: {
+    isEnabled?: boolean;
+}) => {
+    highestApr: GqlRewardVaultDynamicData["apr"] | undefined;
+    isLoading: boolean;
+    refresh: () => void;
+};
+
+declare const usePollGlobalData: (options?: DefaultHookOptions) => DefaultHookReturnType<GlobalData>;
+
+interface UsePollMarketsResponse extends DefaultHookReturnType<GetMarkets> {
+}
+declare const usePollMarketsQueryKey: () => string;
+declare const usePollMarkets: (options?: DefaultHookOptions) => UsePollMarketsResponse;
+
+declare function useQueuedBeraUnlock({ receiptTokenAddress, account, version, }: {
+    receiptTokenAddress?: Address | string;
+    account?: Address | string;
+    version: "V1" | "V2";
+}, options?: DefaultHookOptions): {
+    refresh: () => Promise<StakedBeraWithdrawal[] | undefined>;
+    data: StakedBeraWithdrawal[] | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<StakedBeraWithdrawal[]>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useRewardTokenToBeraRate: ({ address, }: {
+    address: Address | undefined;
+}, opt?: DefaultHookOptions) => swr.SWRResponse<number, any, {
+    errorRetryInterval?: number | undefined;
+    errorRetryCount?: number;
+    loadingTimeout?: number | undefined;
+    focusThrottleInterval?: number | undefined;
+    dedupingInterval?: number | undefined;
+    refreshInterval?: number | ((latestData: any) => number) | undefined;
+    refreshWhenHidden?: boolean;
+    refreshWhenOffline?: boolean;
+    revalidateOnFocus?: boolean | undefined;
+    revalidateOnReconnect?: boolean | undefined;
+    revalidateOnMount?: boolean;
+    revalidateIfStale?: boolean | undefined;
+    shouldRetryOnError?: boolean | ((err: any) => boolean) | undefined;
+    keepPreviousData?: boolean;
+    suspense?: boolean;
+    fallbackData?: any;
+    fetcher?: swr.BareFetcher<any> | undefined;
+    use?: swr.Middleware[];
+    fallback?: {
+        [key: string]: any;
+    } | undefined;
+    isPaused?: (() => boolean) | undefined;
+    onLoadingSlow?: ((key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>) => void) | undefined;
+    onSuccess?: ((data: any, key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>) => void) | undefined;
+    onError?: ((err: any, key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>) => void) | undefined;
+    onErrorRetry?: ((err: any, key: string, config: Readonly<swr__internal.PublicConfiguration<any, any, swr.BareFetcher<any>>>, revalidate: swr.Revalidator, revalidateOpts: Required<swr.RevalidatorOptions>) => void) | undefined;
+    onDiscarded?: ((key: string) => void) | undefined;
+    compare?: ((a: any, b: any) => boolean) | undefined;
+    isOnline?: (() => boolean) | undefined;
+    isVisible?: (() => boolean) | undefined;
+    initFocus?: ((callback: () => void) => (() => void) | void) | undefined;
+    initReconnect?: ((callback: () => void) => (() => void) | void) | undefined;
+    provider?: (cache: Readonly<swr.Cache>) => swr.Cache;
+    isEnabled?: boolean;
+}>;
+
+interface UseRewardVaultResponse extends DefaultHookReturnType<ApiVaultFragment> {
+}
+declare const useRewardVaultQueryKey: (address: Address | undefined) => readonly ["useRewardVault", `0x${string}`] | null;
+declare const useRewardVault: (id: Address | undefined, options?: DefaultHookOptions) => UseRewardVaultResponse;
+
+declare const useRewardVaultBalanceFromStakingToken: ({ stakingToken, rewardVaultAddress: _rewardVaultAddress, }: {
+    stakingToken: Address | undefined;
+    rewardVaultAddress?: Address;
+}, options?: DefaultHookOptions) => {
+    refresh: () => void;
+    isLoading: boolean;
+    data: {
+        address: `0x${string}`;
+        balance: bigint;
+    } | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<{
+        address: `0x${string}`;
+        balance: bigint;
+    }>;
+    isValidating: boolean;
+};
+
+declare const useRewardVaultFromToken: ({ tokenAddress, }: {
+    tokenAddress: Address | string | undefined;
+}, { isEnabled, }?: {
+    isEnabled?: boolean;
+}) => {
+    refresh: () => Promise<`0x${string}` | undefined>;
+    data: `0x${string}` | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<`0x${string}` | undefined>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare function useRewardVaultIncentives({ address, stakingToken, }: {
+    address: Address | undefined;
+    stakingToken: Address | undefined;
+}): {
+    refresh: () => Promise<RewardVaultIncentive[] | undefined>;
+    data: RewardVaultIncentive[] | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<RewardVaultIncentive[]>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useRewardVaultRewards: (address: Address, options?: DefaultHookOptions) => {
+    refresh: () => Promise<GetRewardVaultRewardsReturn | undefined>;
+    data: GetRewardVaultRewardsReturn | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<GetRewardVaultRewardsReturn>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useRewardVaultsQueryKey: (filter?: GetVaultsQueryVariables, onChainIncentives?: boolean) => readonly ["useRewardVaults", _berachain_graphql_pol_api.Exact<{
+    where?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.GqlRewardVaultFilter>;
+    pageSize?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.Scalars["Int"]["input"]>;
+    skip?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.Scalars["Int"]["input"]>;
+    orderBy?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.GqlRewardVaultOrderBy>;
+    orderDirection?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.GqlRewardVaultOrderDirection>;
+    search?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.Scalars["String"]["input"]>;
+}> | undefined, boolean];
+declare const useRewardVaults: (args: {
+    filter?: GetVaultsQueryVariables;
+    onChainIncentives?: boolean;
+}, options?: DefaultHookOptions) => {
+    refresh: swr.KeyedMutator<GetGaugeData>;
+    data: GetGaugeData | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<GetGaugeData>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare const useStakedBeraSnapshots: ({ range, }: GetStakedBeraSnapshotsArgs) => DefaultHookReturnType<GetSWberaVaultSnapshotsQuery["polGetSWberaVaultSnapshots"]>;
+
+declare const useUserVaultInfo: (args: {
+    vaultAddress: Address | undefined;
+}, options?: DefaultHookOptions) => DefaultHookReturnType<UserVaultInfo>;
+
+declare const useUserVaults: (options?: DefaultHookOptions) => DefaultHookReturnType<GetUserVaultsResponse>;
+
+interface RewardVault {
+    stakeToken: Address;
+    address: Address;
+}
+declare const useVaultAddress: (vaultAddress: Address) => swr.SWRResponse<{
+    stakeToken: `0x${string}`;
+    address: `0x${string}`;
+}, any, any>;
+
+declare const useVaultHistory: ({ vault, range, resolution, }: GetVaultHistoryArgs) => DefaultHookReturnType<GetVaultHistoryQuery["polGetRewardVaultSnapshots"]>;
+
+interface UsePollValidatorInfoResponse$1 extends DefaultHookReturnType<ApiValidatorFragment[] | undefined> {
+}
+declare const useVaultValidators: (id: Address, options?: DefaultHookOptions) => UsePollValidatorInfoResponse$1;
+
+/**
+ * Shorthand for `useTokenCurrentPrice` with the Bera token address.
+ * @returns
+ */
+declare function useBeraCurrentPrice(opts?: DefaultHookOptions): DefaultHookReturnType<TokenPriceInfo>;
+
+type UseMultipleTokenInformationResponse = DefaultHookReturnType<Token[]>;
+type useMultipleTokenInformationArgs = {
+    addresses: string[] | readonly string[] | undefined;
+};
+declare const useMultipleTokenInformation: (args: useMultipleTokenInformationArgs, options?: DefaultHookOptions) => UseMultipleTokenInformationResponse;
+
+type UsePollAllowancesArgs = {
+    spender: string | undefined;
+    tokens: Token[];
+};
+interface UsePollAllowancesResponse extends DefaultHookReturnType<AllowanceToken[] | undefined> {
+}
+/**
+ *
+ * @brief Allows the user to poll the allowances of a given token array.
+ *
+ * @param contract the address of the ERC20 token contract
+ * @param tokens   the list of tokens to poll allowances for
+ */
+declare const usePollAllowances: (args: UsePollAllowancesArgs, options?: DefaultHookOptions) => UsePollAllowancesResponse;
+
+declare function usePollBalance({ address: addressString, owner, chainId, }: {
+    /**
+     * Token address to get the balance of
+     */
+    address: string | undefined;
+    owner?: Address | undefined;
+    chainId?: number;
+}, options?: DefaultHookOptions): Omit<DefaultHookReturnType<BalanceToken | undefined>, "mutate">;
+
+type UsePollWalletBalancesArgs = {
+    /**
+     * If provided, the tokens will be used instead of the default token list.
+     */
+    tokens?: Token[];
+    walletAddress?: Address;
+};
+interface UsePollBalancesResponse extends DefaultHookReturnType<BalanceToken[] | undefined> {
+}
+declare function usePollWalletBalances(args?: UsePollWalletBalancesArgs, options?: DefaultHookOptions): UsePollBalancesResponse;
+
+type UseStakingTokenInformationResponse = DefaultHookReturnType<Partial<Token> | undefined>;
+type useStakingTokenInformationArgs = {
+    address: string | undefined;
+};
+declare const useStakingTokenInformation: (args: useStakingTokenInformationArgs, options?: DefaultHookOptions) => UseStakingTokenInformationResponse;
+
+declare function useTokenCurrentPrice({ address }: {
+    address: `0x${string}` | undefined;
+}, options?: DefaultHookOptions): DefaultHookReturnType<TokenPriceInfo>;
+
+declare function useTokenCurrentPrices({ addressIn, }?: {
+    addressIn?: string[] | readonly string[];
+}, options?: DefaultHookOptions): DefaultHookReturnType<TokenCurrentPriceMap>;
+
+type UseTokenInformationResponse = DefaultHookReturnType<Token | undefined>;
+type UseTokenInformationArgs = {
+    address: string | undefined;
+    chainId?: number;
+};
+declare const useTokenInformation: (args: UseTokenInformationArgs, options?: DefaultHookOptions) => UseTokenInformationResponse;
+
+declare function useTokens(): {
+    /**
+     * @deprecated use useTokens().tokenList instead
+     */
+    data: {
+        tokenList: TokenWithMetadata[];
+        customTokenList: Token[];
+        featuredTokenList: TokenWithMetadata[];
+    };
+    tokenList: TokenWithMetadata[];
+    userTokens: Token[];
+    featuredTokens: TokenWithMetadata[];
+    onRemoveToken: (token: Token) => void;
+    onAddToken: (token: Token) => void;
+};
+
+declare function useTotalSupply({ address }: {
+    address: Address | undefined;
+}): swr.SWRResponse<bigint, any, any>;
+
+type TransactionStatus = "pending" | "confirmed" | "failed";
+interface Transaction {
+    hash: string;
+    description: string;
+    actionType?: TransactionActionType;
+    timestamp: number;
+    status: TransactionStatus;
+    confirmations?: number;
+    chainId: number;
+}
+type NewTransaction = Omit<Transaction, "status">;
+type DataLegacy = Record<string, Record<number, Transaction[] | undefined>>;
+type Data = Record<string, Transaction[] | undefined>;
+declare function safeParseJsonData<T = DataLegacy | Data>(string: string | null): T;
+/**
+ *
+ * @param legacyData - The legacy data to convert to the new data format.
+ * removes the nested chains and converts the data to a flat array.
+ * @returns Data in the new format with the chainId added to each transaction.
+ */
+declare function convertLegacyDataToNewData(legacyData: DataLegacy): Data;
+/**
+ * Filter out duplicate transactions by hash
+ */
+declare const filterDuplicatefn: (tx: Transaction, idx: number, arr: Transaction[]) => boolean;
+declare function mergeData(legacyData: DataLegacy, newData: Data): Data;
+declare function createTransactionStore({ config }: {
+    config: Config;
+}): {
+    addTransaction: (account: string, transaction: NewTransaction) => void;
+    clearTransactions: (account: string) => void;
+    getTransactions: (account: string) => Transaction[];
+    onChange: (fn: () => void) => () => void;
+    waitForPendingTransactions: (account: string) => Promise<void>;
+};
+type TransactionStore = ReturnType<typeof createTransactionStore>;
+
+declare function TransactionStoreProvider({ children, }: {
+    children: react__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useTransactionStore(): TransactionStore;
+
+declare function useAddRecentTransaction(): (transaction: NewTransaction) => void;
+
+declare function useRecentTransactions(): Transaction[];
+
+/**
+ *
+ * @returns Timestamp in seconds
+ */
+declare function useBlockToTimestamp(inputBlock: number | bigint | string): number | undefined;
+
+declare function useBeraContractWrite({ onlyPermissionless, onSuccess, onError, onLoading, onWarning, onSubmission, }?: IUseContractWriteArgs & {
+    /**
+     * Whether to allow only permissionless transactions.
+     *
+     * This is useful when UI is reading data for another account compared to the connected account.
+     */
+    onlyPermissionless?: boolean;
+}): UseContractWriteApi;
+
+declare const useGetVerifiedAbi: (address?: string) => swr.SWRResponse<string, any, swr.SWRConfiguration<string, any, ((arg: readonly [any, ...unknown[]]) => swr__internal.FetcherResponse<string>) | ((arg: readonly [any, ...unknown[]]) => swr__internal.FetcherResponse<string>)> | undefined>;
+
+type UseHistoryStateOptions<T> = {
+    key: string;
+    defaultValue: T;
+};
+/**
+ * useHistoryState is a hook that allows storing state in the browser's history state
+ * it is useful for storing state that you want to persist across pages
+ * It is indexed by the key parameter to be able to store multiple states on the same page and
+ * also to not override nextjs usage of the history state
+ * @param {string} key - the key to store the state under
+ * @param {T} defaultValue - the default value to use if the state is not found
+ * @returns {T} state - the current state
+ * @returns {function} setHistoryState - a function to set the state
+ */
+declare function useHistoryState<T>({ key, defaultValue, }: UseHistoryStateOptions<T>): readonly [T, (value: T | ((prev: T) => T)) => void];
+
+/**
+ * Returns the previous value of a variable before the render
+ * @param value - the value to return the previous value for
+ */
+declare function usePrevious<T>(value: T): T | undefined;
+
+declare const useAllValidatorsQueryKey: ({ variables, }?: {
+    variables?: GetValidatorsQueryVariables;
+}) => (string | _berachain_graphql_pol_api.Exact<{
+    where?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.GqlValidatorFilter>;
+    sortBy?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.GqlValidatorOrderBy>;
+    sortOrder?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.GqlValidatorOrderDirection>;
+    pageSize?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.Scalars["Int"]["input"]>;
+    skip?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.Scalars["Int"]["input"]>;
+    search?: _berachain_graphql_pol_api.InputMaybe<_berachain_graphql_pol_api.Scalars["String"]["input"]>;
+    chain?: _berachain_graphql_pol_api.InputMaybe<GqlChain>;
+}> | undefined)[];
+declare const useAllValidators: (variables: GetValidatorsQueryVariables & BeraJS.BaseFunctionArgs, options?: DefaultHookOptions) => DefaultHookReturnType<GetValidatorsQuery | undefined>;
+
+declare function useApiEnrichedAllocation({ allocation, }: {
+    allocation: ValidatorRewardAllocation | undefined;
+}): swr.SWRResponse<_berachain_graphql_pol_api.ApiRewardAllocationWeightFragment[], any, any>;
+
+interface UsePollValidatorInfoResponse extends DefaultHookReturnType<GetValidatorQuery> {
+}
+declare const useApiValidatorQueryKey: (id: Address) => readonly ["useApiValidator", `0x${string}`] | null;
+declare const useApiValidator: (id: Address, options?: DefaultHookOptions) => UsePollValidatorInfoResponse;
+
+declare function useBaselineRewardAllocation(): swr.SWRResponse<ValidatorRewardAllocation, any, any>;
+
+declare const useDailyValidatorBlockStats: ({ pubKey, first, }: {
+    pubKey: Address | undefined;
+    first?: number;
+}) => DefaultHookReturnType<GetValidatorBlockStatsQuery>;
+
+declare function useDefaultRewardAllocation(options?: DefaultHookOptions): {
+    refresh: () => Promise<ValidatorRewardAllocation | undefined>;
+    data: ValidatorRewardAllocation | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<ValidatorRewardAllocation | undefined>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+/**
+ * Return the validators managed by the account
+ * Roles:
+ * - Validator Operator
+ * - Validator Reward Allocator
+ * @param address
+ * @param options
+ * @returns
+ */
+declare const useManagedValidatorByAccount: ({ account }: {
+    account: Address | undefined;
+}, options?: DefaultHookOptions) => {
+    refresh: () => Promise<_berachain_graphql_pol_subgraph.GetValidatorByAccountQuery | undefined>;
+    data: _berachain_graphql_pol_subgraph.GetValidatorByAccountQuery | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<_berachain_graphql_pol_subgraph.GetValidatorByAccountQuery | undefined>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+type ManagedValidatorRole = {
+    operator: Address | null;
+    rewardAllocator: Address | null;
+    hasOperatorRole: boolean;
+    hasRewardAllocatorRole: boolean;
+};
+declare function useManagedValidatorRole({ pubKey, account: accountAddress, }: {
+    pubKey: Address | undefined;
+    account?: Address | undefined;
+}, options?: DefaultHookOptions): DefaultHookReturnType<ManagedValidatorRole | undefined>;
+
+declare const useOnChainValidator: ({ pubkey }: {
+    pubkey: Address;
+}, options: DefaultHookOptions) => DefaultHookReturnType<Partial<ApiValidatorFragment>>;
+
+declare const useStakingPoolBatch: ({ valPubKey, options, }: {
+    valPubKey: Address;
+    options?: DefaultHookOptions;
+}) => DefaultHookReturnType<number | undefined>;
+
+declare const useSubgraphUserValidators: ({ account: _account, }?: {
+    account?: Address;
+}) => swr.SWRResponse<{
+    __typename?: "UserBoost";
+    id: `0x${string}`;
+    queuedBoostAmount: string;
+    activeBoostAmount: string;
+    queuedDropBoostAmount: string;
+    queuedDropBoostStartBlock?: string | null;
+    queuedBoostStartBlock?: string | null;
+    user: `0x${string}`;
+    validator: {
+        __typename?: "Validator";
+        id: `0x${string}`;
+        publicKey: `0x${string}`;
+        activeBoostAmount: string;
+    };
+}[], any, any>;
+
+interface UseUserActiveValidatorsResponse extends DefaultHookReturnType<ValidatorWithUserBoost[] | undefined> {
+}
+declare const useUserActiveValidators: (options?: DefaultHookOptions) => UseUserActiveValidatorsResponse;
+
+declare const useUserBoostsOnValidator: ({ pubkey, ...args }: {
+    pubkey: Address | undefined;
+    account?: Address;
+}) => DefaultHookReturnType<UserBoostsOnValidator>;
+
+interface UseUserClaimableIncentivesReturnType extends DefaultHookReturnType<BribeBoostRewardProof[]> {
+    tokenMap?: Set<string> | undefined;
+}
+declare const useUserClaimableIncentives: () => UseUserClaimableIncentivesReturnType;
+
+/**
+ * Hook to fetch and manage user staking positions for validators
+ *
+ * This hook retrieves staking positions for a given account and optionally filters
+ * by a specific validator address.
+ *
+ * @param params - Configuration parameters for the hook
+ * @param params.account - The user's wallet address to fetch staking positions for
+ * @param params.validatorAddress - Optional validator address to filter positions by
+ *
+ *
+ * @example
+ * ```tsx
+ * // Fetch all staking positions for a user
+ * const { data, isLoading, error } = useUserStakingPositions({
+ *   account: userAddress
+ * });
+ *
+ * // Fetch staking positions for a specific validator
+ * const { data, isLoading, error } = useUserStakingPositions({
+ *   account: userAddress,
+ *   validatorAddress: "0x1234..."
+ * });
+ * ```
+ */
+declare const useUserStakingPositions: ({ account, validatorAddress, }: {
+    account: Address | undefined;
+    validatorAddress?: Address;
+}) => {
+    refresh: () => void;
+    data: UserStakingPoolPosition[] | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<UserStakingPoolPosition[]>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+declare function useValidator({ pubkey }: {
+    pubkey: Address;
+}, options: DefaultHookOptions): {
+    data: {
+        uptime: {
+            __typename?: "GqlValidatorBlockUptime";
+            isActive: boolean;
+            isProposer: boolean;
+            isSigner: boolean;
+            status: _berachain_graphql_pol_api.GqlValidatorBlockUptimeStatus;
+            blockNumber: number;
+        }[] | undefined;
+        validator: {
+            operator: `0x${string}` | null | undefined;
+            dynamicData: {
+                activeBoostAmount: string;
+                queuedBoostAmount: string;
+                usersActiveBoostCount: number;
+                usersQueuedBoostCount: number;
+                allTimeDistributedBGTAmount: string;
+                rewardRate: string;
+                stakedBeraAmount: string;
+                lastDayDistributedBGTAmount: string;
+                activeBoostAmountRank: number;
+                boostApr: GqlValidatorDynamicData["boostApr"];
+                commissionOnIncentives: number;
+            };
+            id: Address;
+            pubkey: Address;
+            metadata: {
+                __typename?: "GqlValidatorMetadata";
+                name: string;
+                logoURI: string;
+                website: string;
+                description: string;
+            } | null | undefined;
+            rewardAllocationWeights: {
+                __typename?: "GqlValidatorRewardAllocationWeight";
+                percentage: number;
+                receiver: `0x${string}`;
+                startBlock: number;
+                receivingVault?: {
+                    __typename?: "GqlRewardVault";
+                    vaultAddress: `0x${string}`;
+                    isVaultWhitelisted: boolean;
+                    stakingTokenAmount: string;
+                    id: `0x${string}`;
+                    address: `0x${string}`;
+                    dynamicData?: {
+                        __typename?: "GqlRewardVaultDynamicData";
+                        allTimeReceivedBGTAmount: string;
+                        apr?: number | null;
+                        bgtCapturePercentage: string;
+                        bgtCapturePerBlock: string;
+                        activeIncentivesValueUsd: string;
+                        activeIncentivesRateUsd: string;
+                        tvl?: number | null;
+                    } | null;
+                    stakingToken: {
+                        __typename?: "GqlToken";
+                        address: `0x${string}`;
+                        name: string;
+                        symbol: string;
+                        decimals: number;
+                    };
+                    metadata?: {
+                        __typename?: "GqlRewardVaultMetadata";
+                        name: string;
+                        logoURI: string;
+                        url: string;
+                        protocolName: string;
+                        protocolIcon: string;
+                        description: string;
+                        categories: Array<string>;
+                        action: string;
+                    } | null;
+                    activeIncentives: Array<{
+                        __typename?: "GqlRewardVaultIncentive";
+                        active: boolean;
+                        remainingAmount: string;
+                        remainingAmountUsd: string;
+                        incentiveRate: string;
+                        incentiveRateUsd: string;
+                        tokenAddress: `0x${string}`;
+                        token: {
+                            __typename?: "GqlToken";
+                            address: `0x${string}`;
+                            name: string;
+                            symbol: string;
+                            decimals: number;
+                        };
+                    }>;
+                } | null;
+            }[];
+            __typename?: "GqlValidator";
+            rewardAllocator?: `0x${string}` | null;
+            lastBlockUptime?: {
+                __typename?: "GqlValidatorBlockUptime";
+                isActive: boolean;
+                isProposer: boolean;
+                isSigner: boolean;
+                status: _berachain_graphql_pol_api.GqlValidatorBlockUptimeStatus;
+                blockNumber: number;
+            } | null | undefined;
+        } | null;
+    };
+    isLoading: boolean;
+    error: any;
+};
+
+declare const useValidatorAnalytics: ({ pubkey, dayRange, }: {
+    pubkey: Address | undefined;
+    dayRange: number;
+}) => DefaultHookReturnType<GetValidatorAnalyticsQuery>;
+
+declare const useValidatorCommission: (pubKey: Address, options?: DefaultHookOptions) => DefaultHookReturnType<number | undefined | null>;
+
+declare const useValidatorEstimatedBgtPerYear: (validator: ApiValidatorMinimalFragment) => {
+    data: number | undefined;
+    isLoading: boolean;
+};
+
+declare function useValidatorQueuedCommission(pubKey: Address, options?: DefaultHookOptions): DefaultHookReturnType<ValidatorQueuedCommission | undefined | null>;
+
+declare const useValidatorQueuedOperatorAddress: (pubKey: Address, options?: DefaultHookOptions) => DefaultHookReturnType<ValidatorQueuedOperatorAddress | undefined>;
+
+declare const useValidatorQueuedRewardAllocation: (pubKey: Address, options?: DefaultHookOptions) => DefaultHookReturnType<ValidatorRewardAllocation | undefined>;
+
+declare function useValidatorRewardAllocation(pubKey: Address, options?: DefaultHookOptions): {
+    refresh: () => Promise<{
+        activeRewardAllocation: ValidatorRewardAllocation;
+        setRewardAllocation: ValidatorRewardAllocation;
+        isBaseline: boolean;
+        isNeverSet: boolean;
+    } | undefined>;
+    data: {
+        activeRewardAllocation: ValidatorRewardAllocation;
+        setRewardAllocation: ValidatorRewardAllocation;
+        isBaseline: boolean;
+        isNeverSet: boolean;
+    } | undefined;
+    error: any;
+    mutate: swr.KeyedMutator<{
+        activeRewardAllocation: ValidatorRewardAllocation;
+        setRewardAllocation: ValidatorRewardAllocation;
+        isBaseline: boolean;
+        isNeverSet: boolean;
+    }>;
+    isValidating: boolean;
+    isLoading: boolean;
+};
+
+export { BalanceTokenWithMetadata, type Data, type DataLegacy, GetZapTransactionResponse, IHoneySwapState, IUseContractWriteArgs, type LiquidityMismatchInfo, type ManagedValidatorRole, type NewTransaction, type OnChainPoolFragment, type Oracle, OracleMode, type RewardVault, type Transaction, type TransactionStore, TransactionStoreProvider, USE_AGGREGATORS_QUOTES_QUERY_KEY, type UseCappedGloballyResponse, type UseCappedRelativelyResponse, type UseCollateralWeightsResponse, UseContractWriteApi, type UseIsBadCollateralResponse, type UseMultipleTokenInformationResponse, type UsePollAllowancesArgs, type UsePollAllowancesResponse, type UsePollBalancesResponse, type UsePollMarketsResponse, type UsePollProposalResponse, type UsePollValidatorInfoResponse, type UsePollWalletBalancesArgs, type UseRewardVaultResponse, type UseStakingTokenInformationResponse, type UseTokenInformationArgs, type UseTokenInformationResponse, convertLegacyDataToNewData, createTransactionStore, filterDuplicatefn, mergeData, safeParseJsonData, useAddRecentTransaction, useAggregatorsQuotes, useAggregatorsRouterFeeBps, useAllUserPools, useAllUserPoolsQueryKey, useAllValidators, useAllValidatorsQueryKey, useApiEnrichedAllocation, useApiPool, useApiPoolQueryKey, useApiValidator, useApiValidatorQueryKey, useBaselineRewardAllocation, useBendTransactionRequests, useBendTransactionRequestsHelper, useBeraContractWrite, useBeraCurrentPrice, useBgtAprSimulation, useBgtUnstakedBalance, useBlockToTimestamp, useCappedGlobally, useCappedRelatively, useClaimableFees, useCollateralWeights, useCreatePool, useCreateProposal, useDailyValidatorBlockStats, useDefaultRewardAllocation, useEarnedStakedBeraVault, useEnsoZap, useExploitedTokens, useExploitedTokensQueryKey, useGetConvertToAssets, useGetPastVotes, useGetVerifiedAbi, useGlobalLiquidityAndSwapVolume, useHasVoted, useHighestVaultsAPR, useHistoryState, useHoneyAlerts, useHoneyBalances, useHoneyChartData, useHoneyGlobalData, useHoneyVaultsBalance, useIsBadCollateralAsset, useIsBasketModeEnabled, useIsCanceller, useLiquidityMismatch, useLpPosition, useManagedValidatorByAccount, useManagedValidatorRole, useMultipleTokenApprovalsWithSlippage, useMultipleTokenInformation, type useMultipleTokenInformationArgs, useOnChainPoolData, useOnChainPoolDataQueryKey, useOnChainValidator, usePollAllProposals, usePollAllProposalsQueryKey, usePollAllowances, usePollBalance, usePollGlobalData, usePollMarkets, usePollMarketsQueryKey, usePollPoolCreationRelayerApproval, usePollProposal, usePollProposalThreshold, usePollProposalVotes, usePollProposalVotesQueryKey, usePollUserDelegates, usePollWalletBalances, usePool, usePoolEvents, usePoolHistoricalData, usePools, usePoolsQueryKey, usePrevious, useProposalFromTx, useProposalSnapshot, useProposalState, useProposalTimelockState, usePythLatestPrices, usePythUpdateFee, useQueuedBeraUnlock, useQuorum, useRecentTransactions, useRewardTokenToBeraRate, useRewardVault, useRewardVaultBalanceFromStakingToken, useRewardVaultFromToken, useRewardVaultIncentives, useRewardVaultQueryKey, useRewardVaultRewards, useRewardVaults, useRewardVaultsQueryKey, useStakedBeraSnapshots, useStakingPoolBatch, useStakingTokenInformation, type useStakingTokenInformationArgs, useSubgraphPoolQueryKey, useSubgraphUserValidators, useTokenCurrentPrice, useTokenCurrentPrices, useTokenInformation, useTokens, useTotalSupply, useTransactionStore, useUserActiveValidators, useUserBoostsOnValidator, useUserClaimableIncentives, useUserStakingPositions, useUserVaultInfo, useUserVaults, useValidator, useValidatorAnalytics, useValidatorCommission, useValidatorEstimatedBgtPerYear, useValidatorQueuedCommission, useValidatorQueuedOperatorAddress, useValidatorQueuedRewardAllocation, useValidatorRewardAllocation, useVaultAddress, useVaultHistory, useVaultValidators, useZapTransactionRequests };