@berachain/berajs 0.3.0 → 0.3.1

package/dist/generated/beep.d.ts

@@ -0,0 +1,1597 @@
+export type paths = {
+    "/v0/stake/{vault}/earnings/{owner}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description FIFO share-lot earnings (realized/unrealized) for an owner in an LST vault. */
+        get: operations["getStakeEarnings"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/stake/{vault}/stats-by-day": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Per-day total_assets / total_supply snapshots for an LST vault over the requested look-back window. */
+        get: operations["getStakeStatsByDay"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/stake/apr": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description sWBERA vault APR annualized over the requested look-back interval. Annualizes the exchange-rate delta between the latest snapshot and the one closest to now-interval, using the actual gap between them. */
+        get: operations["getStakeApr"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/stake/apr/history": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Daily sWBERA APR history over the requested look-back span (days). Each day carries a trailing-window APR — the annualized exchange-rate change from ~`window` days prior (weekly=7d, daily=1d; default weekly). */
+        get: operations["getStakeAprHistory"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/validators": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description List of all validators with current registry + boost summary. */
+        get: operations["listValidators"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/validators/block-stats/{interval}/{at}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Transpose of /:pubkey/block-stats: a single interval-aligned bucket across all validators, one row each. */
+        get: operations["getBlockStatsByBucket"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/validators/incentives/{interval}/{at}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Transpose of /:pubkey/incentives: a single interval-aligned bucket across all (validator, token) pairs. */
+        get: operations["getIncentivesByBucket"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/validators/{pubkey}/block-stats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Time-bucketed BlockReward rollup scoped to a single validator. */
+        get: operations["getValidatorBlockStats"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/validators/{pubkey}/incentives": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Time-bucketed incentive distribution rollup for a single validator (one row per bucket + token). */
+        get: operations["getValidatorIncentives"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/blocks/block-stats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Time-bucketed chain-wide block-reward statistics with cumulative all-time totals. */
+        get: operations["getBlockStats"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/honey/transactions/latest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Paginated list of the most recent Honey mint/redeem transactions, grouped by tx hash with per-collateral amounts. Optionally filtered to a single type via `?type=MINT|REDEEM`. */
+        get: operations["listHoneyTransactions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/honey/snapshots/{interval}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Time-bucketed Honey volume snapshots (mint, redeem, total) plus cumulative total supply, for a given interval granularity. */
+        get: operations["listHoneySnapshots"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/earn/{vault}/earnings/{owner}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description FIFO share-lot earnings (realized/unrealized) for an owner in an earn vault. */
+        get: operations["getEarnEarnings"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/earn/{vault}/total-assets-by-day": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Per-day total-asset snapshots derived from ExchangeRateUpdated events within a date range. */
+        get: operations["getEarnTotalAssetsByDay"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/earn/{vault}/stats-by-day": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Cached per-day vault stats for the last N days (30, 60, 90, or 365). */
+        get: operations["getEarnStatsByDay"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/earn/{vault}/daily-assets/{owner}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Per-day balance, deposited, and yield chart for an owner in an earn vault. */
+        get: operations["getEarnDailyAssets"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/stats/bera": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description BERA total and circulating supply. */
+        get: operations["getBeraSupply"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Paginated list of all reward vaults with stakingTokenAmount, USD tvl + isWhitelisted. */
+        get: operations["listRewardVaults"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults/distributions/{interval}/{at}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Transpose of /:vault/distributions: a single interval-aligned bucket across all vaults, one row each. */
+        get: operations["getVaultDistributionsByBucket"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults/{vault}/distributions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Time-bucketed Distributor.Distributed rollup keyed by receiver for a single vault. */
+        get: operations["getVaultDistributions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults/global-info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Chain-wide PoL summary singleton. */
+        get: operations["getGlobalInfo"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults/protocols": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Every protocol that operates at least one currently-whitelisted reward vault. */
+        get: operations["listRewardVaultProtocols"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults/incentives": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Every incentive token currently whitelisted on at least one live reward vault (unique by token address). */
+        get: operations["listWhitelistedIncentives"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/reward-vaults/user-vault-stakes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Per-(user, vault) staked-LP balances. */
+        get: operations["listUserVaultStakes"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v0/tokens/prices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** @description Latest price for each requested token; never-priced tokens are omitted. */
+        get: operations["listTokenPrices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+};
+export type webhooks = Record<string, never>;
+export type components = {
+    schemas: {
+        ValidationError: {
+            /** @constant */
+            success: false;
+            /** @description Validation issues that caused the rejection */
+            error: ({
+                message: string;
+                path?: (string | number)[];
+            } & {
+                [key: string]: unknown;
+            })[];
+            /** @description The raw request value that failed validation */
+            data: unknown;
+        };
+        TransferHistoryLimitExceededError: {
+            /** @constant */
+            error: "transfer_history_limit_exceeded";
+            limit: number;
+        };
+        TransferRateUnavailableError: {
+            /** @constant */
+            error: "transfer_rate_unavailable";
+        };
+        ClientIdError: {
+            /** @constant */
+            error: "missing_client_id";
+            message: string;
+        };
+        /** @description Signed integer encoded as a base-10 string (digits only, optional leading '-') */
+        BigIntStr: string;
+        StakeStatsByDayEntry: {
+            total_assets: components["schemas"]["BigIntStr"] | null;
+            total_supply: components["schemas"]["BigIntStr"] | null;
+            timestamp: number;
+        };
+        StakeAprHistoryEntry: {
+            timestamp: number;
+            /** @deprecated */
+            apr: number | null;
+            apy: number | null;
+        };
+        Validator: {
+            id: components["schemas"]["Bytes32Hex"];
+            pubkey: components["schemas"]["ValidatorPubkeyStr"];
+            credentials: components["schemas"]["Bytes32Hex"];
+            operator: components["schemas"]["EvmAddress"] | null;
+            rewardAllocator: components["schemas"]["EvmAddress"] | null;
+            queuedBoosts: components["schemas"]["DecimalStr"];
+            queuedDropBoosts: components["schemas"]["DecimalStr"];
+            metadata: components["schemas"]["ValidatorMetadata"];
+        };
+        /** @description 32-byte hex value: 0x followed by 64 hex characters */
+        Bytes32Hex: string;
+        /** @description 48-byte BLS validator pubkey: 0x followed by 96 hex characters */
+        ValidatorPubkeyStr: string;
+        /** @description 20-byte EVM address: 0x followed by 40 hex characters */
+        EvmAddress: string;
+        /** @description Decimal number encoded as a string (e.g. '12', '-3.5') */
+        DecimalStr: string;
+        ValidatorMetadata: {
+            /** @description Display name; null when the validator has no metadata entry */
+            name: string | null;
+            /** @description Free-text validator description */
+            description: string | null;
+            /** @description Validator website URL */
+            website: string | null;
+            /** @description Validator logo image URL */
+            logoUri: string | null;
+            /** @description Validator Twitter/X handle or URL */
+            twitter: string | null;
+        };
+        ValidatorBlockStatsByValidator: {
+            validatorId: components["schemas"]["Bytes32Hex"];
+            timestamp: number;
+            blockCount: number;
+            earnedRewardAmount: components["schemas"]["DecimalStr"];
+            distributedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeBlockCount: number;
+            allTimeEarnedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeDistributedRewardAmount: components["schemas"]["DecimalStr"];
+        };
+        ValidatorIncentiveDistribution: {
+            timestamp: number;
+            validatorId: components["schemas"]["Bytes32Hex"];
+            token: components["schemas"]["EvmAddress"];
+            receivedTokenAmount: components["schemas"]["DecimalStr"];
+            allTimeReceivedTokenAmount: components["schemas"]["DecimalStr"];
+        };
+        ValidatorBlockStats: {
+            timestamp: number;
+            blockCount: number;
+            earnedRewardAmount: components["schemas"]["DecimalStr"];
+            distributedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeBlockCount: number;
+            allTimeEarnedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeDistributedRewardAmount: components["schemas"]["DecimalStr"];
+        };
+        BlockStats: {
+            timestamp: number;
+            blockCount: number;
+            earnedRewardAmount: components["schemas"]["DecimalStr"];
+            distributedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeBlockCount: number;
+            allTimeEarnedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeDistributedRewardAmount: components["schemas"]["DecimalStr"];
+        };
+        HoneyLatestTransaction: {
+            txHash: string;
+            /** @enum {string} */
+            type: "MINT" | "REDEEM";
+            collaterals: components["schemas"]["HoneyCollateral"][];
+            to: components["schemas"]["EvmAddress"];
+            from: components["schemas"]["EvmAddress"];
+            honeyAmount: components["schemas"]["DecimalStr"];
+            timestamp: number;
+        };
+        HoneyCollateral: {
+            address: components["schemas"]["EvmAddress"];
+            amount: components["schemas"]["DecimalStr"];
+        };
+        HoneySnapshot: {
+            timestamp: number;
+            mintVolume: components["schemas"]["DecimalStr"];
+            redeemVolume: components["schemas"]["DecimalStr"];
+            totalVolume: components["schemas"]["DecimalStr"];
+            totalSupply: components["schemas"]["DecimalStr"];
+        };
+        EarnTotalAssetsByDayEntry: {
+            total_assets: components["schemas"]["BigIntStr"] | null;
+            total_supply: components["schemas"]["BigIntStr"] | null;
+            timestamp: number;
+        };
+        EarnDailyAssetsEntry: {
+            timestamp: number;
+            balance: number;
+            deposited: number;
+            yield: number;
+        };
+        RewardVault: {
+            address: components["schemas"]["EvmAddress"];
+            stakingToken: components["schemas"]["EvmAddress"];
+            stakingTokenAmount: components["schemas"]["DecimalStr"];
+            /** @description USD TVL = stakingTokenAmount × latest staking-token price, rounded to 4 dp; null when unpriced or decimals unknown */
+            tvl: number | null;
+            isWhitelisted: boolean;
+            metadata: components["schemas"]["RewardVaultMetadata"];
+        };
+        RewardVaultMetadata: {
+            /** @description Vault page URL; null when the vault has no metadata entry */
+            url: string | null;
+            /** @description Vault logo image URL */
+            logoUri: string | null;
+            /** @description Free-text vault description */
+            description: string | null;
+            /** @description Raw "category/subcategory" tags; empty when none */
+            categories: string[];
+            /** @description Suggested user action for the vault (e.g. stake) */
+            action: string | null;
+            /** @description Operating protocol; null when the vault names none */
+            protocol: components["schemas"]["RewardVaultProtocol"] | null;
+        };
+        RewardVaultProtocol: {
+            /** @description Protocol name (grouping key) */
+            name: string;
+            /** @description Free-text protocol description */
+            description: string | null;
+            /** @description Protocol website URL */
+            url: string | null;
+            /** @description Protocol logo image URL */
+            logoUri: string | null;
+        };
+        VaultDistribution: {
+            timestamp: number;
+            vaultId: components["schemas"]["EvmAddress"];
+            receivedRewardAmount: components["schemas"]["DecimalStr"];
+            allTimeReceivedRewardAmount: components["schemas"]["DecimalStr"];
+        };
+        WhitelistedIncentive: {
+            address: components["schemas"]["EvmAddress"];
+            decimals: number;
+            name: string | null;
+            symbol: string | null;
+        };
+        UserVaultStake: {
+            /** @description Concatenated (user, vault) identifier */
+            id: string;
+            user: components["schemas"]["EvmAddress"];
+            vaultId: components["schemas"]["EvmAddress"];
+            amount: components["schemas"]["DecimalStr"];
+            updatedAtBlock: number;
+        };
+        TokenCurrentPrice: {
+            address: components["schemas"]["EvmAddress"];
+            /** @description Latest recorded USD price. Use `timestamp` to assess freshness. */
+            price: number;
+            /** @description Epoch seconds when this price was last recorded. */
+            timestamp: number;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+};
+export type $defs = Record<string, never>;
+export interface operations {
+    getStakeEarnings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+                owner: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Earnings totals for the owner */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        currentDepositRate: components["schemas"]["BigIntStr"];
+                        earningsTotal: components["schemas"]["BigIntStr"];
+                        earningsRealized: components["schemas"]["BigIntStr"];
+                        earningsUnrealized: components["schemas"]["BigIntStr"];
+                    };
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+            /** @description Earnings cannot be computed exactly for this owner history */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TransferHistoryLimitExceededError"] | components["schemas"]["TransferRateUnavailableError"];
+                };
+            };
+        };
+    };
+    getStakeStatsByDay: {
+        parameters: {
+            query: {
+                days: "30" | "60" | "90" | "365";
+            };
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Per-day vault stats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StakeStatsByDayEntry"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getStakeApr: {
+        parameters: {
+            query: {
+                interval: "SIX_HOURS" | "TWELVE_HOURS" | "EIGHTEEN_HOURS" | "ONE_DAY" | "SEVEN_DAYS";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description APR plus the rates and actual hours used for annualization */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @deprecated */
+                        apr: number | null;
+                        apy: number | null;
+                        /** @enum {string} */
+                        interval: "SIX_HOURS" | "TWELVE_HOURS" | "EIGHTEEN_HOURS" | "ONE_DAY" | "SEVEN_DAYS";
+                    };
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getStakeAprHistory: {
+        parameters: {
+            query: {
+                days: "7" | "30" | "60" | "90";
+                window?: "weekly" | "daily";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Ascending daily series of trailing-7d APR + exchange rate */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StakeAprHistoryEntry"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    listValidators: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Validators */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Validator"][];
+                };
+            };
+            /** @description Missing required X-Client-Id header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClientIdError"];
+                };
+            };
+        };
+    };
+    getBlockStatsByBucket: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                interval: "hour" | "day";
+                at: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Block stats for the bucket, one row per validator */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidatorBlockStatsByValidator"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getIncentivesByBucket: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                interval: "hour" | "day";
+                at: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Incentive distributions for the bucket, one row per (validator, token) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidatorIncentiveDistribution"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getValidatorBlockStats: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                /** @description Time bucket size (default: day) */
+                interval?: "hour" | "day";
+                /** @description Epoch-seconds cutoff; only buckets at/after are returned */
+                after?: string;
+            };
+            header?: never;
+            path: {
+                pubkey: components["schemas"]["ValidatorPubkeyStr"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Validator block stats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidatorBlockStats"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getValidatorIncentives: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                /** @description Time bucket size (default: day) */
+                interval?: "hour" | "day";
+                /** @description Epoch-seconds cutoff; only buckets at/after are returned */
+                after?: string;
+            };
+            header?: never;
+            path: {
+                pubkey: components["schemas"]["ValidatorPubkeyStr"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Validator incentive distribution */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidatorIncentiveDistribution"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getBlockStats: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                /** @description Time bucket size (default: day) */
+                interval?: "hour" | "day";
+                /** @description Epoch-seconds cutoff; only buckets at/after are returned */
+                after?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Block stats buckets */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BlockStats"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    listHoneyTransactions: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                type?: "MINT" | "REDEEM";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Honey transactions */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HoneyLatestTransaction"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    listHoneySnapshots: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+            };
+            header?: never;
+            path: {
+                interval: "hour" | "day" | "week" | "month";
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Honey snapshots */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HoneySnapshot"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getEarnEarnings: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+                owner: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Earnings totals for the owner */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        currentDepositRate: components["schemas"]["BigIntStr"];
+                        earningsTotal: components["schemas"]["BigIntStr"];
+                        earningsRealized: components["schemas"]["BigIntStr"];
+                        earningsUnrealized: components["schemas"]["BigIntStr"];
+                    };
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+            /** @description Earnings cannot be computed exactly for this owner history */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TransferHistoryLimitExceededError"] | components["schemas"]["TransferRateUnavailableError"];
+                };
+            };
+        };
+    };
+    getEarnTotalAssetsByDay: {
+        parameters: {
+            query: {
+                start: string;
+                end?: string;
+            };
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Per-day total-asset snapshots */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EarnTotalAssetsByDayEntry"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getEarnStatsByDay: {
+        parameters: {
+            query: {
+                days: "30" | "60" | "90" | "365";
+            };
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Per-day vault stats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EarnTotalAssetsByDayEntry"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getEarnDailyAssets: {
+        parameters: {
+            query?: {
+                start?: string;
+            };
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+                owner: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Per-day owner chart points */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["EarnDailyAssetsEntry"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+            /** @description Earnings cannot be computed exactly for this owner history */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TransferHistoryLimitExceededError"] | components["schemas"]["TransferRateUnavailableError"];
+                };
+            };
+        };
+    };
+    getBeraSupply: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description BERA supply */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        totalSupply: components["schemas"]["DecimalStr"];
+                        circulatingSupply: components["schemas"]["DecimalStr"];
+                    };
+                };
+            };
+            /** @description Missing required X-Client-Id header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClientIdError"];
+                };
+            };
+        };
+    };
+    listRewardVaults: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                orderBy?: "stakingTokenAmount" | "tvl" | "address";
+                orderDirection?: "asc" | "desc";
+                /** @description Filter by whitelist status; defaults to whitelisted-only */
+                status?: "all" | "whitelisted";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Reward vaults */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RewardVault"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getVaultDistributionsByBucket: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                interval: "hour" | "day";
+                at: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Vault distributions for the bucket */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VaultDistribution"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getVaultDistributions: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                /** @description Time bucket size (default: day) */
+                interval?: "hour" | "day";
+                /** @description Epoch-seconds cutoff; only buckets at/after are returned */
+                after?: string;
+                sort?: "asc" | "desc";
+                /** @description Exact bucket boundary (epoch seconds); excludes after/page/perPage */
+                at?: string;
+            };
+            header?: never;
+            path: {
+                vault: components["schemas"]["EvmAddress"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Vault distributions */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["VaultDistribution"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    getGlobalInfo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Global PoL info */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        totalDistributedAmount: components["schemas"]["DecimalStr"];
+                        totalQueuedBoostAmount: components["schemas"]["DecimalStr"];
+                    };
+                };
+            };
+            /** @description Missing required X-Client-Id header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClientIdError"];
+                };
+            };
+        };
+    };
+    listRewardVaultProtocols: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Reward-vault protocols */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RewardVaultProtocol"][];
+                };
+            };
+            /** @description Missing required X-Client-Id header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClientIdError"];
+                };
+            };
+        };
+    };
+    listWhitelistedIncentives: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Whitelisted incentive tokens */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WhitelistedIncentive"][];
+                };
+            };
+            /** @description Missing required X-Client-Id header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClientIdError"];
+                };
+            };
+        };
+    };
+    listUserVaultStakes: {
+        parameters: {
+            query?: {
+                /** @description Page number, 1 or greater */
+                page?: string;
+                /** @description Items per page, 1–1000 (per-endpoint default) */
+                perPage?: string;
+                user?: components["schemas"]["EvmAddress"];
+                vault?: components["schemas"]["EvmAddress"];
+                /** @description Only stakes updated at/after this block */
+                afterBlock?: string;
+                orderBy?: "updatedAtBlock" | "amount" | "id";
+                orderDirection?: "asc" | "desc";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description User vault stakes */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UserVaultStake"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+    listTokenPrices: {
+        parameters: {
+            query: {
+                /** @description Comma-separated EVM addresses (max 100) */
+                addresses: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Prices */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TokenCurrentPrice"][];
+                };
+            };
+            /** @description Request validation failed */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationError"];
+                };
+            };
+        };
+    };
+}
+export type ApiSchema<TName extends keyof components["schemas"]> = components["schemas"][TName];
+export type ApiGetResponse<TPath extends keyof paths> = paths[TPath] extends {
+    get: {
+        responses: {
+            200: {
+                content: {
+                    "application/json": infer TResponse;
+                };
+            };
+        };
+    };
+} ? TResponse : never;
+export type ValidationError = components["schemas"]["ValidationError"];
+export type TransferHistoryLimitExceededError = components["schemas"]["TransferHistoryLimitExceededError"];
+export type TransferRateUnavailableError = components["schemas"]["TransferRateUnavailableError"];
+export type ClientIdError = components["schemas"]["ClientIdError"];
+export type BigIntStr = components["schemas"]["BigIntStr"];
+export type StakeStatsByDayEntry = components["schemas"]["StakeStatsByDayEntry"];
+export type StakeAprHistoryEntry = components["schemas"]["StakeAprHistoryEntry"];
+export type Validator = components["schemas"]["Validator"];
+export type Bytes32Hex = components["schemas"]["Bytes32Hex"];
+export type ValidatorPubkeyStr = components["schemas"]["ValidatorPubkeyStr"];
+export type EvmAddress = components["schemas"]["EvmAddress"];
+export type DecimalStr = components["schemas"]["DecimalStr"];
+export type ValidatorMetadata = components["schemas"]["ValidatorMetadata"];
+export type ValidatorBlockStatsByValidator = components["schemas"]["ValidatorBlockStatsByValidator"];
+export type ValidatorIncentiveDistribution = components["schemas"]["ValidatorIncentiveDistribution"];
+export type ValidatorBlockStats = components["schemas"]["ValidatorBlockStats"];
+export type BlockStats = components["schemas"]["BlockStats"];
+export type HoneyLatestTransaction = components["schemas"]["HoneyLatestTransaction"];
+export type HoneyCollateral = components["schemas"]["HoneyCollateral"];
+export type HoneySnapshot = components["schemas"]["HoneySnapshot"];
+export type EarnTotalAssetsByDayEntry = components["schemas"]["EarnTotalAssetsByDayEntry"];
+export type EarnDailyAssetsEntry = components["schemas"]["EarnDailyAssetsEntry"];
+export type RewardVault = components["schemas"]["RewardVault"];
+export type RewardVaultMetadata = components["schemas"]["RewardVaultMetadata"];
+export type RewardVaultProtocol = components["schemas"]["RewardVaultProtocol"];
+export type VaultDistribution = components["schemas"]["VaultDistribution"];
+export type WhitelistedIncentive = components["schemas"]["WhitelistedIncentive"];
+export type UserVaultStake = components["schemas"]["UserVaultStake"];
+export type TokenCurrentPrice = components["schemas"]["TokenCurrentPrice"];
+export type StakeEarningResponse = paths["/v0/stake/{vault}/earnings/{owner}"]["get"]["responses"][200]["content"]["application/json"];
+export type StakeStatsByDayResponse = paths["/v0/stake/{vault}/stats-by-day"]["get"]["responses"][200]["content"]["application/json"];
+export type StakeAprResponse = paths["/v0/stake/apr"]["get"]["responses"][200]["content"]["application/json"];
+export type StakeAprHistoryResponse = paths["/v0/stake/apr/history"]["get"]["responses"][200]["content"]["application/json"];
+export type ValidatorsResponse = paths["/v0/validators"]["get"]["responses"][200]["content"]["application/json"];
+export type ValidatorsBlockStatResponse = paths["/v0/validators/block-stats/{interval}/{at}"]["get"]["responses"][200]["content"]["application/json"];
+export type ValidatorsIncentiveResponse = paths["/v0/validators/incentives/{interval}/{at}"]["get"]["responses"][200]["content"]["application/json"];
+export type ValidatorBlockStatsResponse = paths["/v0/validators/{pubkey}/block-stats"]["get"]["responses"][200]["content"]["application/json"];
+export type ValidatorIncentivesResponse = paths["/v0/validators/{pubkey}/incentives"]["get"]["responses"][200]["content"]["application/json"];
+export type BlocksBlockStatsResponse = paths["/v0/blocks/block-stats"]["get"]["responses"][200]["content"]["application/json"];
+export type HoneyTransactionsLatestResponse = paths["/v0/honey/transactions/latest"]["get"]["responses"][200]["content"]["application/json"];
+export type HoneySnapshotResponse = paths["/v0/honey/snapshots/{interval}"]["get"]["responses"][200]["content"]["application/json"];
+export type EarnEarningResponse = paths["/v0/earn/{vault}/earnings/{owner}"]["get"]["responses"][200]["content"]["application/json"];
+export type EarnTotalAssetsByDayResponse = paths["/v0/earn/{vault}/total-assets-by-day"]["get"]["responses"][200]["content"]["application/json"];
+export type EarnStatsByDayResponse = paths["/v0/earn/{vault}/stats-by-day"]["get"]["responses"][200]["content"]["application/json"];
+export type EarnDailyAssetResponse = paths["/v0/earn/{vault}/daily-assets/{owner}"]["get"]["responses"][200]["content"]["application/json"];
+export type StatsBeraResponse = paths["/v0/stats/bera"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultsResponse = paths["/v0/reward-vaults"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultsDistributionResponse = paths["/v0/reward-vaults/distributions/{interval}/{at}"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultDistributionsResponse = paths["/v0/reward-vaults/{vault}/distributions"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultsGlobalInfoResponse = paths["/v0/reward-vaults/global-info"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultsProtocolsResponse = paths["/v0/reward-vaults/protocols"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultsIncentivesResponse = paths["/v0/reward-vaults/incentives"]["get"]["responses"][200]["content"]["application/json"];
+export type RewardVaultsUserVaultStakesResponse = paths["/v0/reward-vaults/user-vault-stakes"]["get"]["responses"][200]["content"]["application/json"];
+export type TokensPricesResponse = paths["/v0/tokens/prices"]["get"]["responses"][200]["content"]["application/json"];
+//# sourceMappingURL=beep.d.ts.map