@berachain/graphql 0.1.0-alpha.9 → 0.1.0

package/dist/bend/whisk.codegen.d.mts

@@ -0,0 +1,1798 @@
+import * as graphql from 'graphql';
+
+type Maybe<T> = T | null;
+type InputMaybe<T> = Maybe<T>;
+type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Address: {
+        input: `0x${string}`;
+        output: `0x${string}`;
+    };
+    BigInt: {
+        input: string;
+        output: string | bigint;
+    };
+    ChainId: {
+        input: 80094;
+        output: 80094;
+    };
+    Hex: {
+        input: `0x${string}`;
+        output: `0x${string}`;
+    };
+    URL: {
+        input: string;
+        output: string;
+    };
+};
+/** Aera vault */
+type AeraVault = {
+    __typename?: 'AeraVault';
+    /** Chain the vault is deployed on */
+    chain: Chain;
+    /** Vault-level paused flag (guardian operations) */
+    isPaused: Scalars['Boolean']['output'];
+    /** Management fee of the vault */
+    managementFee: OnchainAmount;
+    /** Name of the vault */
+    name: Scalars['String']['output'];
+    /** Numeraire asset of the vault */
+    numeraireAsset: Token;
+    /** Performance fee of the vault */
+    performanceFee: OnchainAmount;
+    /** APY earned when supplying to the vault smoothed over 1 day. */
+    supplyApy1d: Apy;
+    /** APY earned when supplying to the vault smoothed over 7 days. */
+    supplyApy7d: Apy;
+    /** APY earned when supplying to the vault smoothed over 30 days. */
+    supplyApy30d: Apy;
+    /** Total amount of the numeraire assets supplied to the vault */
+    totalSupplied: TokenAmount;
+    /** Address of the vault contract */
+    vaultAddress: Scalars['Address']['output'];
+};
+/** Filter for Aera vaults */
+type AeraVaultFilter = {
+    /** Filter for certain chainIds */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+    /** Filter for certain vault addresses */
+    vaultAddress_in: InputMaybe<Array<Scalars['Address']['input']>>;
+};
+/** Page of Aera vaults */
+type AeraVaultPage = {
+    __typename?: 'AeraVaultPage';
+    /** The items in the page */
+    items: Array<Maybe<AeraVault>>;
+    /** Pagination information for the page */
+    pageInfo: PageInfo;
+    /** Total number of items */
+    totalCount: Scalars['Int']['output'];
+};
+/** Position of an account in an Aera vault */
+type AeraVaultPosition = {
+    __typename?: 'AeraVaultPosition';
+    /** Address of the account */
+    accountAddress: Scalars['Address']['output'];
+    /** Whether the account has a pending deposit */
+    hasPendingDeposit: Scalars['Boolean']['output'];
+    /** Whether the account has a pending withdrawal */
+    hasPendingWithdrawal: Scalars['Boolean']['output'];
+    /** Position balance in numeraire assets */
+    supplyAmount: TokenAmount;
+    /** Position balance in shares */
+    supplyShares: OnchainAmount;
+    /** Vault the position is in */
+    vault: AeraVault;
+};
+/** Filter for Aera vault positions */
+type AeraVaultPositionFilter = {
+    /** Filter for certain account addresses */
+    accountAddress_in: InputMaybe<Array<Scalars['Address']['input']>>;
+    /** Filter for certain chainIds */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+    /** Filter for certain vault addresses */
+    vaultAddress_in: InputMaybe<Array<Scalars['Address']['input']>>;
+};
+/** Page of Aera vault positions */
+type AeraVaultPositionPage = {
+    __typename?: 'AeraVaultPositionPage';
+    /** The items in the page */
+    items: Array<Maybe<AeraVaultPosition>>;
+    /** Pagination information for the page */
+    pageInfo: PageInfo;
+    /** Total number of items */
+    totalCount: Scalars['Int']['output'];
+};
+/** Annual Percentage Yield (APY) of an opportunity */
+type Apy = {
+    __typename?: 'Apy';
+    /** The base APY. For Supply: rate earned by supplying. For Borrow: rate paid for borrowing. Will always be positive. */
+    base: Scalars['Float']['output'];
+    /** Fees that reduce the effective APY (decreasing Supply APY, increasing Borrow APY). Will always be positive. */
+    fee: Scalars['Float']['output'];
+    /** Additional reward tokens that improve the total APY (increasing Supply APY, decreasing Borrow APY). The APRs will always be positive. */
+    rewards: Array<Reward>;
+    /** Whether this APY applies to the supply or borrow side of an opportunity */
+    side: ApySide;
+    /** The net APY after combining base rate, rewards, and fees (base + rewards - fee). Negative borrow APY means being paid to borrow. */
+    total: Scalars['Float']['output'];
+};
+/** Whether an APY applies to the supply or borrow side of an opportunity */
+declare enum ApySide {
+    /** APY paid when borrowing */
+    Borrow = "Borrow",
+    /** APY earned when supplying */
+    Supply = "Supply"
+}
+/** A blockchain */
+type Chain = {
+    __typename?: 'Chain';
+    /** URL to the chain's icon/logo image */
+    icon: Scalars['URL']['output'];
+    /** Unique blockchain identifier */
+    id: Scalars['ChainId']['output'];
+    /** Human-readable name of the blockchain (e.g., 'Ethereum', 'Polygon') */
+    name: Scalars['String']['output'];
+    /** The native token of the blockchain (e.g., ETH for Ethereum) */
+    nativeToken: Token;
+    /** The wrapped version of the native token (e.g., WETH for Ethereum) */
+    wrappedNativeToken: Token;
+};
+/** Filter for chains */
+type ChainFilter = {
+    /** Filter for certain chainIds */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+};
+/** Curator of a Morpho vault */
+type Curator = {
+    __typename?: 'Curator';
+    /** Image of the curator */
+    image: Scalars['String']['output'];
+    /** Name of the curator */
+    name: Scalars['String']['output'];
+    /** URL of the curator */
+    url: Scalars['String']['output'];
+};
+type Identity = {
+    __typename?: 'Identity';
+    aggregate: IdentityResolverOutput;
+    base: IdentityResolverOutput;
+    ens: IdentityResolverOutput;
+    farcaster: IdentityResolverOutput;
+    isOfacSanctioned: Scalars['Boolean']['output'];
+    lens: IdentityResolverOutput;
+    nns: IdentityResolverOutput;
+    uni: IdentityResolverOutput;
+    world: IdentityResolverOutput;
+};
+declare enum IdentityResolver {
+    Base = "base",
+    Ens = "ens",
+    Farcaster = "farcaster",
+    Lens = "lens",
+    Nns = "nns",
+    Uni = "uni",
+    World = "world"
+}
+type IdentityResolverOutput = {
+    __typename?: 'IdentityResolverOutput';
+    avatar: Maybe<Scalars['String']['output']>;
+    bio: Maybe<Scalars['String']['output']>;
+    discord: Maybe<Scalars['String']['output']>;
+    github: Maybe<Scalars['String']['output']>;
+    name: Maybe<Scalars['String']['output']>;
+    telegram: Maybe<Scalars['String']['output']>;
+    website: Maybe<Scalars['String']['output']>;
+    x: Maybe<Scalars['String']['output']>;
+};
+/** A reward earned by an account */
+type MerklAccountReward = {
+    __typename?: 'MerklAccountReward';
+    /** The amount of tokens that are currently claimable (creditedAmount - claimedAmount) */
+    claimableAmount: TokenAmount;
+    /** The total amount of tokens that have been credited to the account. This value should be used in the claim call with the proof. */
+    creditedAmount: TokenAmount;
+    /** The address of the contract that distributes the rewards */
+    distributorAddress: Scalars['Address']['output'];
+    /** The amount of the token that will become claimable on the next Merkle Root update (not yet credited to the account) */
+    pendingAmount: TokenAmount;
+    /** The Merkle proofs to claim the claimable tokens */
+    proofs: Array<Scalars['Hex']['output']>;
+    /** The token being rewarded */
+    token: Token;
+};
+declare enum MerklAction {
+    Borrow = "Borrow",
+    Lend = "Lend"
+}
+type MerklRewardInput = {
+    /** The action of the opportunity */
+    action: MerklAction;
+    /** The chain ID of the main protocol */
+    chainId: Scalars['ChainId']['input'];
+    /** The identifier (a.k.a mainParameter) of the reward (ex. vault address for a Morpho vault) */
+    identifier: Scalars['String']['input'];
+    /** The main protocol ID the rewards are on (ex. 'morpho'), see https://api.merkl.xyz/v4/protocols */
+    mainProtocolId: Scalars['String']['input'];
+};
+/** Interest rate model of a Morpho market */
+type MorphoIrm = {
+    __typename?: 'MorphoIrm';
+    /** Address of the IRM contract */
+    address: Scalars['Address']['output'];
+    /** Curve of the IRM */
+    curve: Maybe<Array<MorphoIrmCurvePoint>>;
+    /** Rate at target of the IRM, only null if the IRM is not the adaptive curve IRM */
+    rateAtTarget: Maybe<Scalars['BigInt']['output']>;
+    /** Target utilization of the IRM */
+    targetUtilization: Scalars['Float']['output'];
+};
+/** Curve point of an IRM */
+type MorphoIrmCurvePoint = {
+    __typename?: 'MorphoIrmCurvePoint';
+    /** Base APY paid for borrowing from the market at this utilization */
+    borrowApy: Scalars['Float']['output'];
+    /** Base APY earned for supplying to the market at this utilization */
+    supplyApy: Scalars['Float']['output'];
+    /** Utilization at this curve point */
+    utilization: Scalars['Float']['output'];
+};
+/** Morpho market */
+type MorphoMarket = {
+    __typename?: 'MorphoMarket';
+    /** APY paid for borrowing from the market (instantaneous) */
+    borrowApy: Apy;
+    /** APY paid for borrowing from the market smoothed over 1 day. Note rewards are instantaneous, and base is instantaneous when the market has been deployed less than 1 day ago. */
+    borrowApy1d: Apy;
+    /** APY paid for borrowing from the market smoothed over 7 days. Note rewards are instantaneous, and base is instantaneous when the market has been deployed less than 7 days ago. */
+    borrowApy7d: Apy;
+    /** APY paid for borrowing from the market smoothed over 30 days. Note rewards are instantaneous, and base is instantaneous when the market has been deployed less than 30 days ago. */
+    borrowApy30d: Apy;
+    /** Chain the market is deployed on */
+    chain: Chain;
+    /** Collateral asset of the market, only null for idle or misconfigured markets */
+    collateralAsset: Maybe<Token>;
+    /** Collateral price in loan asset, null if market is idle, or oracle has issue */
+    collateralPriceInLoanAsset: Maybe<OnchainAmount>;
+    /** Fee of the market */
+    fee: OnchainAmount;
+    /** Historical data for the market, will be null if historical data is not supported for this chain */
+    historical: Maybe<MorphoMarketHistorical>;
+    /** IRM of the market */
+    irm: MorphoIrm;
+    /** Whether the market is an idle market (no collateral asset, doesn't earn yield) */
+    isIdle: Scalars['Boolean']['output'];
+    /** Liquidation penalty of the market */
+    liquidationPenalty: Scalars['Float']['output'];
+    /** Amount of loan assets that are idle in the market (not being borrowed) */
+    liquidityInMarket: TokenAmount;
+    /** LLTV of the market */
+    lltv: OnchainAmount;
+    /** Loan asset of the market */
+    loanAsset: Token;
+    /** Unique market ID of the market */
+    marketId: Scalars['Hex']['output'];
+    /** Name of the market */
+    name: Scalars['String']['output'];
+    /** Oracle address of the market */
+    oracleAddress: Scalars['Address']['output'];
+    /** Amount of loan assets that can be allocated to this market via the public allocator */
+    publicAllocatorSharedLiquidity: TokenAmount;
+    /** APY earned for supplying to the market (instantaneous) */
+    supplyApy: Apy;
+    /** APY earned for supplying to the market smoothed over 1 day. Note rewards are instantaneous, and base is instantaneous when the market has been deployed less than 1 day ago. */
+    supplyApy1d: Apy;
+    /** APY earned for supplying to the market smoothed over 7 days. Note rewards are instantaneous, and base is instantaneous when the market has been deployed less than 7 days ago. */
+    supplyApy7d: Apy;
+    /** APY earned for supplying to the market smoothed over 30 days. Note rewards are instantaneous, and base is instantaneous when the market has been deployed less than 30 days ago. */
+    supplyApy30d: Apy;
+    /** Total amount of loan assets borrowed from the market */
+    totalBorrowed: TokenAmount;
+    /** Total amount of loan assets supplied to the market */
+    totalSupplied: TokenAmount;
+    /** Utilization of the market */
+    utilization: Scalars['Float']['output'];
+    /** Allocations from vault to this market */
+    vaultAllocations: Array<MorphoVaultMarketAllocation>;
+};
+/** Filter for Morpho markets */
+type MorphoMarketFilter = {
+    /** Filter for certain chainIds */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+    /** Filter for certain market addresses */
+    marketId_in: InputMaybe<Array<Scalars['Hex']['input']>>;
+    /** Filter for whitelisted markets */
+    whitelisted: InputMaybe<Scalars['Boolean']['input']>;
+};
+/** Historical data for a Morpho market */
+type MorphoMarketHistorical = {
+    __typename?: 'MorphoMarketHistorical';
+    /** Historical data with daily resolution. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    daily: Array<MorphoMarketHistoricalEntry>;
+    /** Historical data with hourly resolution. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    hourly: Array<MorphoMarketHistoricalEntry>;
+    /** Historical data with weekly resolution. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    weekly: Array<MorphoMarketHistoricalEntry>;
+};
+/** Historical entry for a Morpho market */
+type MorphoMarketHistoricalEntry = {
+    __typename?: 'MorphoMarketHistoricalEntry';
+    /** APY paid for borrowing from the market smoothed over 1 day. Note that doesn't yet include rewards */
+    borrowApy1d: Apy;
+    /** APY paid for borrowing from the market smoothed over 7 days. Note that doesn't yet include rewards */
+    borrowApy7d: Apy;
+    /** APY paid for borrowing from the market smoothed over 30 days. Note that doesn't yet include rewards */
+    borrowApy30d: Apy;
+    /** APY paid for borrowing from the market (instantaneous, no smoothing). Note that doesn't yet include rewards */
+    borrowApyInstantaneous: Apy;
+    /** The timestamp of the data rounded down to the nearest resolution (ex. hour, day, week). */
+    bucketTimestamp: Scalars['Int']['output'];
+    /** Collateral price in loan asset, null if market is idle, or oracle has issue */
+    collateralPriceInLoanAsset: Maybe<OnchainAmount>;
+    /** APY earned when supplying to the market smoothed over 1 day. Note that doesn't yet include rewards */
+    supplyApy1d: Apy;
+    /** APY earned when supplying to the market smoothed over 7 days. Note that doesn't yet include rewards */
+    supplyApy7d: Apy;
+    /** APY earned when supplying to the market smoothed over 30 days. Note that doesn't yet include rewards */
+    supplyApy30d: Apy;
+    /** APY earned when supplying to the market (instantaneous, no smoothing). Note that doesn't yet include rewards */
+    supplyApyInstantaneous: Apy;
+    /** Total amount of loan assets borrowed from the market */
+    totalBorrowed: TokenAmount;
+    /** Total amount of collateral supplied to the market */
+    totalCollateral: TokenAmount;
+    /** Total amount of loan assets supplied to the market */
+    totalSupplied: TokenAmount;
+};
+/** Page of Morpho markets */
+type MorphoMarketPage = {
+    __typename?: 'MorphoMarketPage';
+    /** The items in the page */
+    items: Array<Maybe<MorphoMarket>>;
+    /** Pagination information for the page */
+    pageInfo: PageInfo;
+    /** Total number of items */
+    totalCount: Scalars['Int']['output'];
+};
+/** Position of an account in a Morpho market */
+type MorphoMarketPosition = {
+    __typename?: 'MorphoMarketPosition';
+    /** Address of the account */
+    accountAddress: Scalars['Address']['output'];
+    /** Borrow assets of the account */
+    borrowAmount: TokenAmount;
+    /** Borrow shares of the account */
+    borrowShares: Scalars['BigInt']['output'];
+    /** Collateral assets of the account, null iff the market is idle */
+    collateralAmount: Maybe<TokenAmount>;
+    /** Health factor of the account, null iff the market is idle or its oracle is misconfigured */
+    healthFactor: Maybe<OnchainAmount>;
+    /** LTV of the account, null iff the market is idle or its oracle is misconfigured */
+    ltv: Maybe<OnchainAmount>;
+    /** Market the position is in */
+    market: MorphoMarket;
+    /** Supply assets of the account */
+    supplyAmount: TokenAmount;
+    /** Supply shares of the account */
+    supplyShares: Scalars['BigInt']['output'];
+    /** Holding of collateral assets in the account's wallet, null iff the market is idle */
+    walletCollateralAssetHolding: Maybe<TokenHolding>;
+    /** Holding of loan assets in the account's wallet */
+    walletLoanAssetHolding: TokenHolding;
+};
+type MorphoMarketPositionFilter = {
+    /** Filter for positions for certain accounts */
+    accountAddress_in: Array<Scalars['Address']['input']>;
+    /** Filter for positions on certain chains */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+    /** Filter for positions in certain markets */
+    marketId_in: InputMaybe<Array<Scalars['Hex']['input']>>;
+    /** Filter for positions in whitelisted markets only */
+    whitelisted: InputMaybe<Scalars['Boolean']['input']>;
+};
+type MorphoMarketPositionHistorical = {
+    __typename?: 'MorphoMarketPositionHistorical';
+    daily: Array<MorphoMarketPositionHistoricalEntry>;
+    hourly: Array<MorphoMarketPositionHistoricalEntry>;
+    weekly: Array<MorphoMarketPositionHistoricalEntry>;
+};
+type MorphoMarketPositionHistoricalEntry = {
+    __typename?: 'MorphoMarketPositionHistoricalEntry';
+    /** Borrow assets of the account at the bucket timestamp */
+    borrowAmount: TokenAmount;
+    /** The timestamp of the data rounded down to the nearest resolution (ex. hour, day, week). */
+    bucketTimestamp: Scalars['Int']['output'];
+    /** Collateral assets of the account at the bucket timestamp, null iff the market is idle */
+    collateralAmount: Maybe<TokenAmount>;
+    /** Supply assets of the account at the bucket timestamp */
+    supplyAmount: TokenAmount;
+};
+/** Page of Morpho market positions */
+type MorphoMarketPositionPage = {
+    __typename?: 'MorphoMarketPositionPage';
+    /** The items in the page */
+    items: Array<Maybe<MorphoMarketPosition>>;
+    /** Pagination information for the page */
+    pageInfo: PageInfo;
+    /** Total number of items */
+    totalCount: Scalars['Int']['output'];
+};
+/** Morpho vault */
+type MorphoVault = {
+    __typename?: 'MorphoVault';
+    /** Underlying asset of the vault */
+    asset: Token;
+    /** Chain the vault is deployed on */
+    chain: Chain;
+    /** Curator address of the vault, this is the address that can modify the vaults allocations */
+    curatorAddress: Scalars['Address']['output'];
+    /** Decimals of the vault's shares */
+    decimals: Scalars['Int']['output'];
+    /** Fee recipient address of the vault, this is the address that receives the performance fee */
+    feeRecipientAddress: Maybe<Scalars['Address']['output']>;
+    /** Guardian address of the vault, this is the address that can make emergency changes to the vault */
+    guardianAddress: Scalars['Address']['output'];
+    /** Historical data for the vault, will be null if historical data is not supported for this chain */
+    historical: Maybe<MorphoVaultHistorical>;
+    /** Allocations of the vault to the markets */
+    marketAllocations: Array<MorphoVaultMarketAllocation>;
+    /** Metadata for the vault */
+    metadata: Maybe<MorphoVaultMetadata>;
+    /** Name of the vault */
+    name: Scalars['String']['output'];
+    /** Owner address of the vault, this is the address that can modify the vaults configuration */
+    ownerAddress: Scalars['Address']['output'];
+    /** Performance fee of the vault, this is the fee that is taken from the vaults profits */
+    performanceFee: Scalars['Float']['output'];
+    /** APY earned when supplying to the vault (instantaneous) */
+    supplyApy: Apy;
+    /** APY earned when supplying to the vault smoothed over 1 day. Note rewards are instantaneous, and base is instantaneous when the vault has been deployed less than 1 day ago. */
+    supplyApy1d: Apy;
+    /** APY earned when supplying to the vault smoothed over 7 days. Note rewards are instantaneous, and base is instantaneous when the vault has been deployed less than 7 days ago. */
+    supplyApy7d: Apy;
+    /** APY earned when supplying to the vault smoothed over 30 days. Note rewards are instantaneous, and base is instantaneous when the vault has been deployed less than 30 days ago. */
+    supplyApy30d: Apy;
+    /** Total amount of the idle underlying assets (not being borrowed from the vault) */
+    totalLiquidity: TokenAmount;
+    /** Total amount of the underlying assets supplied to the vault */
+    totalSupplied: TokenAmount;
+    /** Address of the vault contract */
+    vaultAddress: Scalars['Address']['output'];
+};
+/** Filter for Morpho vaults */
+type MorphoVaultFilter = {
+    /** Filter for certain chainIds */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+    /** Filter for certain vault addresses */
+    vaultAddress_in: InputMaybe<Array<Scalars['Address']['input']>>;
+    /** Filter for whitelisted vaults */
+    whitelisted: InputMaybe<Scalars['Boolean']['input']>;
+};
+/** Historical data for a Morpho vault */
+type MorphoVaultHistorical = {
+    __typename?: 'MorphoVaultHistorical';
+    /** Historical data with daily resolution. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    daily: Array<MorphoVaultHistoricalEntry>;
+    /** Historical data with hourly resolution. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    hourly: Array<MorphoVaultHistoricalEntry>;
+    /** Historical data with weekly resolution. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    weekly: Array<MorphoVaultHistoricalEntry>;
+};
+/** Historical entry for a Morpho vault */
+type MorphoVaultHistoricalEntry = {
+    __typename?: 'MorphoVaultHistoricalEntry';
+    /** The timestamp of the data rounded down to the nearest resolution (ex. hour, day, week). */
+    bucketTimestamp: Scalars['Int']['output'];
+    /** APY earned when supplying to the vault smoothed over 1 day. Note that doesn't yet include rewards */
+    supplyApy1d: Apy;
+    /** APY earned when supplying to the vault smoothed over 7 days. Note that doesn't yet include rewards */
+    supplyApy7d: Apy;
+    /** APY earned when supplying to the vault smoothed over 30 days. Note that doesn't yet include rewards */
+    supplyApy30d: Apy;
+    /** Total amount of the underlying assets supplied to the vault */
+    totalSupplied: TokenAmount;
+};
+/** Allocation of a vault to a market */
+type MorphoVaultMarketAllocation = {
+    __typename?: 'MorphoVaultMarketAllocation';
+    /** Whether the vault has enabled this market for allocations */
+    enabled: Scalars['Boolean']['output'];
+    /** Market the allocation is to */
+    market: MorphoMarket;
+    /** Share of the market's total supply from this vault */
+    marketSupplyShare: Scalars['Float']['output'];
+    /** Position of the vault in the market */
+    position: MorphoMarketPosition;
+    /** Supply cap of the allocation */
+    supplyCap: TokenAmount;
+    /** Vault the allocation is from */
+    vault: MorphoVault;
+    /** Share of the vault's total supply to this market */
+    vaultSupplyShare: Scalars['Float']['output'];
+};
+/** Metadata for a Morpho vault */
+type MorphoVaultMetadata = {
+    __typename?: 'MorphoVaultMetadata';
+    /**
+     * Curators of the vault
+     * @deprecated Removed from morpho metadata repo. Always empty array now.
+     */
+    curators: Array<Curator>;
+    /** Description of the vault */
+    description: Maybe<Scalars['String']['output']>;
+    /**
+     * Forum link of the vault
+     * @deprecated Removed from morpho metadata repo. Always null now.
+     */
+    forumLink: Maybe<Scalars['String']['output']>;
+    /** Image of the vault */
+    image: Maybe<Scalars['String']['output']>;
+};
+/** Page of Morpho vaults */
+type MorphoVaultPage = {
+    __typename?: 'MorphoVaultPage';
+    /** The items in the page */
+    items: Array<Maybe<MorphoVault>>;
+    /** Pagination information for the page */
+    pageInfo: PageInfo;
+    /** Total number of items */
+    totalCount: Scalars['Int']['output'];
+};
+/** Position of an account in a Morpho vault */
+type MorphoVaultPosition = {
+    __typename?: 'MorphoVaultPosition';
+    /** Address of the account */
+    accountAddress: Scalars['Address']['output'];
+    /** Supply assets of the account */
+    supplyAmount: TokenAmount;
+    /** Supply shares of the account */
+    supplyShares: Scalars['BigInt']['output'];
+    /** Vault the position is in */
+    vault: MorphoVault;
+    /** Holding of the underlying asset in the accounts wallet */
+    walletUnderlyingAssetHolding: Maybe<TokenHolding>;
+};
+type MorphoVaultPositionFilter = {
+    /** Filter for positions for certain accounts */
+    accountAddress_in: Array<Scalars['Address']['input']>;
+    /** Filter for positions on certain chains */
+    chainId_in: InputMaybe<Array<Scalars['ChainId']['input']>>;
+    /** Filter for positions in certain vaults */
+    vaultAddress_in: InputMaybe<Array<Scalars['Address']['input']>>;
+    /** Filter for positions in whitelisted vaults only */
+    whitelisted: InputMaybe<Scalars['Boolean']['input']>;
+};
+type MorphoVaultPositionHistorical = {
+    __typename?: 'MorphoVaultPositionHistorical';
+    daily: Array<MorphoVaultPositionHistoricalEntry>;
+    hourly: Array<MorphoVaultPositionHistoricalEntry>;
+    weekly: Array<MorphoVaultPositionHistoricalEntry>;
+};
+type MorphoVaultPositionHistoricalEntry = {
+    __typename?: 'MorphoVaultPositionHistoricalEntry';
+    /** The timestamp of the data rounded down to the nearest resolution (ex. hour, day, week). */
+    bucketTimestamp: Scalars['Int']['output'];
+    /** Interest earned by the account at the bucket timestamp */
+    interestEarned: TokenAmount;
+    /** Supply shares of the account at the bucket timestamp */
+    supplyAmount: TokenAmount;
+};
+type MorphoVaultPositionPage = {
+    __typename?: 'MorphoVaultPositionPage';
+    /** The items in the page */
+    items: Array<Maybe<MorphoVaultPosition>>;
+    /** Pagination information for the page */
+    pageInfo: PageInfo;
+    /** Total number of items */
+    totalCount: Scalars['Int']['output'];
+};
+/** An arbitrary onchain amount */
+type OnchainAmount = {
+    __typename?: 'OnchainAmount';
+    /** The formatted representation of the amount, this is the raw value scaled by its decimals (formatted = raw / 10^decimals) */
+    formatted: Scalars['String']['output'];
+    /** The integer representation of the amount as stored onchain */
+    raw: Scalars['BigInt']['output'];
+};
+/** Pagination information for a page of items */
+type PageInfo = {
+    __typename?: 'PageInfo';
+    /** The cursor to the last item in the current page, this can be used for the queries `after` parameter to get the next page */
+    endCursor: Maybe<Scalars['String']['output']>;
+    /** Whether there are more items after the current page */
+    hasNextPage: Scalars['Boolean']['output'];
+    /** Whether there are more items before the current page */
+    hasPreviousPage: Scalars['Boolean']['output'];
+    /** The cursor to the first item in the current page, this can be used for the queries `before` parameter to get the previous page */
+    startCursor: Maybe<Scalars['String']['output']>;
+};
+/** Protocol */
+type Protocol = {
+    __typename?: 'Protocol';
+    /** Icon of the protocol */
+    icon: Scalars['String']['output'];
+    /** Name of the protocol */
+    name: Scalars['String']['output'];
+};
+type Query = {
+    __typename?: 'Query';
+    aeraVaultPositions: AeraVaultPositionPage;
+    aeraVaults: AeraVaultPage;
+    /** Get supported chains (note that not all kits support all chains) */
+    chains: Array<Chain>;
+    identities: Array<Identity>;
+    identity: Maybe<Identity>;
+    /** Query for Merkl rewards earned on chainId for the accountAddress */
+    merklAccountRewards: Array<MerklAccountReward>;
+    /** Query for Morpho market positions */
+    morphoMarketPositions: MorphoMarketPositionPage;
+    /** Query for Morpho markets */
+    morphoMarkets: MorphoMarketPage;
+    /** Query for Morpho vault positions */
+    morphoVaultPositions: MorphoVaultPositionPage;
+    /** Query for Morpho vaults */
+    morphoVaults: MorphoVaultPage;
+    /** Query for the token balance for a specific account and token */
+    tokenHoldings: Array<Maybe<TokenHolding>>;
+    /** Query for tokens */
+    tokens: Array<Maybe<Token>>;
+    /** Query for vaults */
+    vaults: Array<Maybe<Vault>>;
+};
+type QueryAeraVaultPositionsArgs = {
+    after: InputMaybe<Scalars['String']['input']>;
+    before: InputMaybe<Scalars['String']['input']>;
+    limit: InputMaybe<Scalars['Int']['input']>;
+    where: AeraVaultPositionFilter;
+};
+type QueryAeraVaultsArgs = {
+    after: InputMaybe<Scalars['String']['input']>;
+    before: InputMaybe<Scalars['String']['input']>;
+    limit: InputMaybe<Scalars['Int']['input']>;
+    where: InputMaybe<AeraVaultFilter>;
+};
+type QueryChainsArgs = {
+    where: InputMaybe<ChainFilter>;
+};
+type QueryIdentitiesArgs = {
+    addresses: Array<Scalars['Address']['input']>;
+    resolverOrder: InputMaybe<Array<IdentityResolver>>;
+};
+type QueryIdentityArgs = {
+    address: Scalars['Address']['input'];
+    resolverOrder: InputMaybe<Array<IdentityResolver>>;
+};
+type QueryMerklAccountRewardsArgs = {
+    accountAddress: Scalars['Address']['input'];
+    chainId: Scalars['ChainId']['input'];
+};
+type QueryMorphoMarketPositionsArgs = {
+    after: InputMaybe<Scalars['String']['input']>;
+    before: InputMaybe<Scalars['String']['input']>;
+    limit: InputMaybe<Scalars['Int']['input']>;
+    where: MorphoMarketPositionFilter;
+};
+type QueryMorphoMarketsArgs = {
+    after: InputMaybe<Scalars['String']['input']>;
+    before: InputMaybe<Scalars['String']['input']>;
+    limit: InputMaybe<Scalars['Int']['input']>;
+    where: InputMaybe<MorphoMarketFilter>;
+};
+type QueryMorphoVaultPositionsArgs = {
+    after: InputMaybe<Scalars['String']['input']>;
+    before: InputMaybe<Scalars['String']['input']>;
+    limit: InputMaybe<Scalars['Int']['input']>;
+    where: MorphoVaultPositionFilter;
+};
+type QueryMorphoVaultsArgs = {
+    after: InputMaybe<Scalars['String']['input']>;
+    before: InputMaybe<Scalars['String']['input']>;
+    limit: InputMaybe<Scalars['Int']['input']>;
+    where: InputMaybe<MorphoVaultFilter>;
+};
+type QueryTokenHoldingsArgs = {
+    inputs: Array<TokenHoldingInput>;
+};
+type QueryTokensArgs = {
+    inputs: Array<TokenInput>;
+};
+type QueryVaultsArgs = {
+    inputs: Array<VaultInput>;
+};
+/** Rewards incentive */
+type Reward = {
+    __typename?: 'Reward';
+    /** The Annual Percentage Rate (APR) for this reward token. Will always be positive. */
+    apr: Scalars['Float']['output'];
+    /** The token being rewarded */
+    asset: Token;
+};
+/** ERC-20 token with metadata and pricing information */
+type Token = {
+    __typename?: 'Token';
+    /** The contract address of the token */
+    address: Scalars['Address']['output'];
+    /** The category of the token */
+    category: Maybe<TokenCategory>;
+    /** The chain this token exists on */
+    chain: Chain;
+    /** The number of decimal places the token uses */
+    decimals: Scalars['Int']['output'];
+    historical: TokenHistorical;
+    /** URL to the token's image, null if not available */
+    icon: Maybe<Scalars['URL']['output']>;
+    /** The full name of the token (e.g., 'Ethereum') */
+    name: Scalars['String']['output'];
+    /** Current price of the token in USD, null iff price data unavailable */
+    priceUsd: Maybe<Scalars['Float']['output']>;
+    /** The symbol of the token (e.g., 'ETH') */
+    symbol: Scalars['String']['output'];
+};
+/** An amount for an onchain token */
+type TokenAmount = {
+    __typename?: 'TokenAmount';
+    /** The formatted representation of the amount, this is the raw value scaled by the token's decimals (formatted = raw / 10^decimals) */
+    formatted: Scalars['String']['output'];
+    /** The integer representation of the amount as stored onchain */
+    raw: Scalars['BigInt']['output'];
+    /** The USD representation of the amount, null if price data unavailable */
+    usd: Maybe<Scalars['Float']['output']>;
+};
+/** The category for a token which can be used to easily group and filter */
+declare enum TokenCategory {
+    /** Bitcoin or Bitcoin derivative (e.g., WBTC, cbBTC) */
+    Btc = "Btc",
+    /** Ether or Ether derivative (e.g., WETH, stETH) */
+    Eth = "Eth",
+    /** Stable coin (e.g., USDC, USDT, DAI) */
+    Stable = "Stable"
+}
+/** Historical token data at different resolutions */
+type TokenHistorical = {
+    __typename?: 'TokenHistorical';
+    /** Historical token data with daily resolution. Null if no price source is configured. Only provides the 200 most recent entries (i.e up to 200 days of data). */
+    daily: Maybe<Array<TokenHistoricalEntry>>;
+    /** Historical token data with hourly resolution. Null if no price source is configured. Only provides the 200 most recent entries (i.e up to 200 hours of data). */
+    hourly: Maybe<Array<TokenHistoricalEntry>>;
+    /** Historical token data with weekly resolution. Null if no price source is configured. Only provides the 200 most recent entries (i.e up to 200 weeks of data). */
+    weekly: Maybe<Array<TokenHistoricalEntry>>;
+};
+/** A single entry of historical token data */
+type TokenHistoricalEntry = {
+    __typename?: 'TokenHistoricalEntry';
+    /** The timestamp of the data rounded down to the nearest resolution (ex. hour, day, week). */
+    bucketTimestamp: Scalars['Int']['output'];
+    /** The price of the token in USD at this bucket timestamp */
+    priceUsd: Scalars['Float']['output'];
+};
+/** Token balance held by a specific account */
+type TokenHolding = {
+    __typename?: 'TokenHolding';
+    /** The address of the account holding the token */
+    accountAddress: Scalars['Address']['output'];
+    /** The balance of the token held by the account */
+    balance: TokenAmount;
+    /** The token being held */
+    token: Token;
+};
+/** Input for querying a token holding */
+type TokenHoldingInput = {
+    /** The address of the account holding the token */
+    accountAddress: Scalars['Address']['input'];
+    /** The chain ID (e.g., 1 for Ethereum mainnet) */
+    chainId: Scalars['ChainId']['input'];
+    /** The token contract address */
+    tokenAddress: Scalars['Address']['input'];
+};
+/** Input for batch token queries, specifying chain and contract address pairs. */
+type TokenInput = {
+    /** The chain ID (e.g., 1 for Ethereum mainnet) */
+    chainId: Scalars['ChainId']['input'];
+    /** The token contract address */
+    tokenAddress: Scalars['Address']['input'];
+};
+/** Input for vaults */
+type VaultInput = {
+    /** Chain the vault is deployed on */
+    chainId: Scalars['ChainId']['input'];
+    /** Protocol the vault is part of */
+    protocol: VaultProtocol;
+    /** Address of the vault */
+    vaultAddress: Scalars['Address']['input'];
+};
+/** Protocols supported by vault kit */
+declare enum VaultProtocol {
+    Enzyme = "enzyme",
+    EulerV2 = "euler_v2",
+    Gearbox = "gearbox",
+    Lista = "lista",
+    Mellow = "mellow",
+    Midas = "midas",
+    Morpho = "morpho",
+    Napier = "napier",
+    Pendle = "pendle",
+    Reserve = "reserve",
+    Silo = "silo",
+    TurtleClub = "turtle_club"
+}
+/** Types of vaults */
+declare enum VaultType {
+    Index = "index",
+    Lending = "lending",
+    Staking = "staking"
+}
+type TokenInfoFragmentFragment = {
+    __typename?: 'Token';
+    address: `0x${string}`;
+    symbol: string;
+    decimals: number;
+    icon: string | null;
+    category: TokenCategory | null;
+};
+type ChainInfoFragmentFragment = {
+    __typename?: 'Chain';
+    id: 80094;
+    name: string;
+    icon: string;
+};
+type CuratorInfoFragmentFragment = {
+    __typename?: 'Curator';
+    name: string;
+    image: string;
+    url: string;
+};
+type ApyFragmentFragment = {
+    __typename?: 'Apy';
+    base: number;
+    total: number;
+    fee: number;
+    rewards: Array<{
+        __typename?: 'Reward';
+        apr: number;
+        asset: {
+            __typename?: 'Token';
+            address: `0x${string}`;
+            symbol: string;
+            decimals: number;
+            icon: string | null;
+            category: TokenCategory | null;
+        };
+    }>;
+};
+type VaultSummaryFragmentFragment = {
+    __typename?: 'MorphoVault';
+    vaultAddress: `0x${string}`;
+    name: string;
+    chain: {
+        __typename?: 'Chain';
+        id: 80094;
+        name: string;
+        icon: string;
+    };
+    asset: {
+        __typename?: 'Token';
+        priceUsd: number | null;
+        address: `0x${string}`;
+        symbol: string;
+        decimals: number;
+        icon: string | null;
+        category: TokenCategory | null;
+    };
+    metadata: {
+        __typename?: 'MorphoVaultMetadata';
+        curators: Array<{
+            __typename?: 'Curator';
+            name: string;
+            image: string;
+            url: string;
+        }>;
+    } | null;
+    totalSupplied: {
+        __typename?: 'TokenAmount';
+        raw: string | bigint;
+        formatted: string;
+        usd: number | null;
+    };
+    totalLiquidity: {
+        __typename?: 'TokenAmount';
+        raw: string | bigint;
+        formatted: string;
+        usd: number | null;
+    };
+    supplyApy: {
+        __typename?: 'Apy';
+        base: number;
+        total: number;
+        fee: number;
+        rewards: Array<{
+            __typename?: 'Reward';
+            apr: number;
+            asset: {
+                __typename?: 'Token';
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            };
+        }>;
+    };
+    marketAllocations: Array<{
+        __typename?: 'MorphoVaultMarketAllocation';
+        vaultSupplyShare: number;
+        market: {
+            __typename?: 'MorphoMarket';
+            collateralAsset: {
+                __typename?: 'Token';
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            } | null;
+            supplyApy: {
+                __typename?: 'Apy';
+                base: number;
+                total: number;
+                fee: number;
+                rewards: Array<{
+                    __typename?: 'Reward';
+                    apr: number;
+                    asset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                }>;
+            };
+            fee: {
+                __typename?: 'OnchainAmount';
+                raw: string | bigint;
+                formatted: string;
+            };
+        };
+    }>;
+};
+type MarketSummaryFragmentFragment = {
+    __typename?: 'MorphoMarket';
+    name: string;
+    marketId: `0x${string}`;
+    chain: {
+        __typename?: 'Chain';
+        id: 80094;
+        name: string;
+        icon: string;
+    };
+    totalBorrowed: {
+        __typename?: 'TokenAmount';
+        raw: string | bigint;
+        formatted: string;
+        usd: number | null;
+    };
+    totalSupplied: {
+        __typename?: 'TokenAmount';
+        raw: string | bigint;
+        formatted: string;
+        usd: number | null;
+    };
+    liquidityInMarket: {
+        __typename?: 'TokenAmount';
+        raw: string | bigint;
+        formatted: string;
+        usd: number | null;
+    };
+    publicAllocatorSharedLiquidity: {
+        __typename?: 'TokenAmount';
+        raw: string | bigint;
+        formatted: string;
+        usd: number | null;
+    };
+    collateralAsset: {
+        __typename?: 'Token';
+        address: `0x${string}`;
+        symbol: string;
+        decimals: number;
+        icon: string | null;
+        category: TokenCategory | null;
+    } | null;
+    loanAsset: {
+        __typename?: 'Token';
+        address: `0x${string}`;
+        symbol: string;
+        decimals: number;
+        icon: string | null;
+        category: TokenCategory | null;
+    };
+    lltv: {
+        __typename?: 'OnchainAmount';
+        raw: string | bigint;
+        formatted: string;
+    };
+    borrowApy: {
+        __typename?: 'Apy';
+        base: number;
+        total: number;
+        fee: number;
+        rewards: Array<{
+            __typename?: 'Reward';
+            apr: number;
+            asset: {
+                __typename?: 'Token';
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            };
+        }>;
+    };
+    vaultAllocations: Array<{
+        __typename?: 'MorphoVaultMarketAllocation';
+        vault: {
+            __typename?: 'MorphoVault';
+            vaultAddress: `0x${string}`;
+        };
+        position: {
+            __typename?: 'MorphoMarketPosition';
+            supplyAmount: {
+                __typename?: 'TokenAmount';
+                usd: number | null;
+            };
+        };
+        supplyCap: {
+            __typename?: 'TokenAmount';
+            usd: number | null;
+        };
+    }>;
+};
+type VaultSummariesQueryVariables = Exact<{
+    chainIds: Array<Scalars['ChainId']['input']> | Scalars['ChainId']['input'];
+    vaultAddresses: Array<Scalars['Address']['input']> | Scalars['Address']['input'];
+}>;
+type VaultSummariesQuery = {
+    __typename?: 'Query';
+    morphoVaults: {
+        __typename?: 'MorphoVaultPage';
+        pageInfo: {
+            __typename?: 'PageInfo';
+            hasNextPage: boolean;
+        };
+        items: Array<{
+            __typename?: 'MorphoVault';
+            vaultAddress: `0x${string}`;
+            name: string;
+            chain: {
+                __typename?: 'Chain';
+                id: 80094;
+                name: string;
+                icon: string;
+            };
+            asset: {
+                __typename?: 'Token';
+                priceUsd: number | null;
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            };
+            metadata: {
+                __typename?: 'MorphoVaultMetadata';
+                curators: Array<{
+                    __typename?: 'Curator';
+                    name: string;
+                    image: string;
+                    url: string;
+                }>;
+            } | null;
+            totalSupplied: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            totalLiquidity: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            supplyApy: {
+                __typename?: 'Apy';
+                base: number;
+                total: number;
+                fee: number;
+                rewards: Array<{
+                    __typename?: 'Reward';
+                    apr: number;
+                    asset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                }>;
+            };
+            marketAllocations: Array<{
+                __typename?: 'MorphoVaultMarketAllocation';
+                vaultSupplyShare: number;
+                market: {
+                    __typename?: 'MorphoMarket';
+                    collateralAsset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    } | null;
+                    supplyApy: {
+                        __typename?: 'Apy';
+                        base: number;
+                        total: number;
+                        fee: number;
+                        rewards: Array<{
+                            __typename?: 'Reward';
+                            apr: number;
+                            asset: {
+                                __typename?: 'Token';
+                                address: `0x${string}`;
+                                symbol: string;
+                                decimals: number;
+                                icon: string | null;
+                                category: TokenCategory | null;
+                            };
+                        }>;
+                    };
+                    fee: {
+                        __typename?: 'OnchainAmount';
+                        raw: string | bigint;
+                        formatted: string;
+                    };
+                };
+            }>;
+        } | null>;
+    };
+};
+type MarketSummariesQueryVariables = Exact<{
+    chainIds: Array<Scalars['ChainId']['input']> | Scalars['ChainId']['input'];
+    marketIds: Array<Scalars['Hex']['input']> | Scalars['Hex']['input'];
+}>;
+type MarketSummariesQuery = {
+    __typename?: 'Query';
+    morphoMarkets: {
+        __typename?: 'MorphoMarketPage';
+        pageInfo: {
+            __typename?: 'PageInfo';
+            hasNextPage: boolean;
+        };
+        items: Array<{
+            __typename?: 'MorphoMarket';
+            name: string;
+            marketId: `0x${string}`;
+            chain: {
+                __typename?: 'Chain';
+                id: 80094;
+                name: string;
+                icon: string;
+            };
+            totalBorrowed: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            totalSupplied: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            liquidityInMarket: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            publicAllocatorSharedLiquidity: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            collateralAsset: {
+                __typename?: 'Token';
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            } | null;
+            loanAsset: {
+                __typename?: 'Token';
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            };
+            lltv: {
+                __typename?: 'OnchainAmount';
+                raw: string | bigint;
+                formatted: string;
+            };
+            borrowApy: {
+                __typename?: 'Apy';
+                base: number;
+                total: number;
+                fee: number;
+                rewards: Array<{
+                    __typename?: 'Reward';
+                    apr: number;
+                    asset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                }>;
+            };
+            vaultAllocations: Array<{
+                __typename?: 'MorphoVaultMarketAllocation';
+                vault: {
+                    __typename?: 'MorphoVault';
+                    vaultAddress: `0x${string}`;
+                };
+                position: {
+                    __typename?: 'MorphoMarketPosition';
+                    supplyAmount: {
+                        __typename?: 'TokenAmount';
+                        usd: number | null;
+                    };
+                };
+                supplyCap: {
+                    __typename?: 'TokenAmount';
+                    usd: number | null;
+                };
+            }>;
+        } | null>;
+    };
+};
+type VaultQueryVariables = Exact<{
+    chainId: Scalars['ChainId']['input'];
+    vaultAddress: Scalars['Address']['input'];
+}>;
+type VaultQuery = {
+    __typename?: 'Query';
+    morphoVaults: {
+        __typename?: 'MorphoVaultPage';
+        items: Array<{
+            __typename?: 'MorphoVault';
+            performanceFee: number;
+            feeRecipientAddress: `0x${string}` | null;
+            ownerAddress: `0x${string}`;
+            curatorAddress: `0x${string}`;
+            guardianAddress: `0x${string}`;
+            vaultAddress: `0x${string}`;
+            name: string;
+            supplyApy1d: {
+                __typename?: 'Apy';
+                total: number;
+            };
+            supplyApy7d: {
+                __typename?: 'Apy';
+                total: number;
+            };
+            supplyApy30d: {
+                __typename?: 'Apy';
+                total: number;
+            };
+            asset: {
+                __typename?: 'Token';
+                priceUsd: number | null;
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            };
+            totalSupplied: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            totalLiquidity: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            marketAllocations: Array<{
+                __typename?: 'MorphoVaultMarketAllocation';
+                enabled: boolean;
+                vaultSupplyShare: number;
+                market: {
+                    __typename?: 'MorphoMarket';
+                    marketId: `0x${string}`;
+                    isIdle: boolean;
+                    name: string;
+                    chain: {
+                        __typename?: 'Chain';
+                        id: 80094;
+                        name: string;
+                        icon: string;
+                    };
+                    lltv: {
+                        __typename?: 'OnchainAmount';
+                        raw: string | bigint;
+                        formatted: string;
+                    };
+                    collateralAsset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    } | null;
+                    loanAsset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                    supplyApy: {
+                        __typename?: 'Apy';
+                        base: number;
+                        total: number;
+                        fee: number;
+                        rewards: Array<{
+                            __typename?: 'Reward';
+                            apr: number;
+                            asset: {
+                                __typename?: 'Token';
+                                address: `0x${string}`;
+                                symbol: string;
+                                decimals: number;
+                                icon: string | null;
+                                category: TokenCategory | null;
+                            };
+                        }>;
+                    };
+                    fee: {
+                        __typename?: 'OnchainAmount';
+                        raw: string | bigint;
+                        formatted: string;
+                    };
+                };
+                position: {
+                    __typename?: 'MorphoMarketPosition';
+                    supplyShares: string | bigint;
+                    supplyAmount: {
+                        __typename?: 'TokenAmount';
+                        raw: string | bigint;
+                        formatted: string;
+                        usd: number | null;
+                    };
+                };
+                supplyCap: {
+                    __typename?: 'TokenAmount';
+                    raw: string | bigint;
+                    formatted: string;
+                    usd: number | null;
+                };
+            }>;
+            chain: {
+                __typename?: 'Chain';
+                id: 80094;
+                name: string;
+                icon: string;
+            };
+            metadata: {
+                __typename?: 'MorphoVaultMetadata';
+                curators: Array<{
+                    __typename?: 'Curator';
+                    name: string;
+                    image: string;
+                    url: string;
+                }>;
+            } | null;
+            supplyApy: {
+                __typename?: 'Apy';
+                base: number;
+                total: number;
+                fee: number;
+                rewards: Array<{
+                    __typename?: 'Reward';
+                    apr: number;
+                    asset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                }>;
+            };
+        } | null>;
+    };
+};
+type MarketQueryVariables = Exact<{
+    chainId: Scalars['ChainId']['input'];
+    marketId: Scalars['Hex']['input'];
+}>;
+type MarketQuery = {
+    __typename?: 'Query';
+    morphoMarkets: {
+        __typename?: 'MorphoMarketPage';
+        items: Array<{
+            __typename?: 'MorphoMarket';
+            isIdle: boolean;
+            utilization: number;
+            liquidationPenalty: number;
+            oracleAddress: `0x${string}`;
+            name: string;
+            marketId: `0x${string}`;
+            totalSupplied: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            totalBorrowed: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            liquidityInMarket: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            publicAllocatorSharedLiquidity: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            collateralAsset: {
+                __typename?: 'Token';
+                priceUsd: number | null;
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            } | null;
+            loanAsset: {
+                __typename?: 'Token';
+                priceUsd: number | null;
+                address: `0x${string}`;
+                symbol: string;
+                decimals: number;
+                icon: string | null;
+                category: TokenCategory | null;
+            };
+            vaultAllocations: Array<{
+                __typename?: 'MorphoVaultMarketAllocation';
+                enabled: boolean;
+                marketSupplyShare: number;
+                vault: {
+                    __typename?: 'MorphoVault';
+                    vaultAddress: `0x${string}`;
+                    name: string;
+                    curatorAddress: `0x${string}`;
+                    asset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                    chain: {
+                        __typename?: 'Chain';
+                        id: 80094;
+                        name: string;
+                        icon: string;
+                    };
+                    metadata: {
+                        __typename?: 'MorphoVaultMetadata';
+                        curators: Array<{
+                            __typename?: 'Curator';
+                            name: string;
+                            image: string;
+                            url: string;
+                        }>;
+                    } | null;
+                };
+                position: {
+                    __typename?: 'MorphoMarketPosition';
+                    supplyShares: string | bigint;
+                    supplyAmount: {
+                        __typename?: 'TokenAmount';
+                        raw: string | bigint;
+                        formatted: string;
+                        usd: number | null;
+                    };
+                };
+                supplyCap: {
+                    __typename?: 'TokenAmount';
+                    raw: string | bigint;
+                    formatted: string;
+                    usd: number | null;
+                };
+            }>;
+            irm: {
+                __typename?: 'MorphoIrm';
+                address: `0x${string}`;
+                targetUtilization: number;
+                curve: Array<{
+                    __typename?: 'MorphoIrmCurvePoint';
+                    utilization: number;
+                    supplyApy: number;
+                    borrowApy: number;
+                }> | null;
+            };
+            collateralPriceInLoanAsset: {
+                __typename?: 'OnchainAmount';
+                raw: string | bigint;
+                formatted: string;
+            } | null;
+            chain: {
+                __typename?: 'Chain';
+                id: 80094;
+                name: string;
+                icon: string;
+            };
+            lltv: {
+                __typename?: 'OnchainAmount';
+                raw: string | bigint;
+                formatted: string;
+            };
+            borrowApy: {
+                __typename?: 'Apy';
+                base: number;
+                total: number;
+                fee: number;
+                rewards: Array<{
+                    __typename?: 'Reward';
+                    apr: number;
+                    asset: {
+                        __typename?: 'Token';
+                        address: `0x${string}`;
+                        symbol: string;
+                        decimals: number;
+                        icon: string | null;
+                        category: TokenCategory | null;
+                    };
+                }>;
+            };
+        } | null>;
+    };
+};
+type VaultPositionsQueryVariables = Exact<{
+    chainIds: Array<Scalars['ChainId']['input']> | Scalars['ChainId']['input'];
+    vaultAddresses: Array<Scalars['Address']['input']> | Scalars['Address']['input'];
+    accountAddress: Scalars['Address']['input'];
+}>;
+type VaultPositionsQuery = {
+    __typename?: 'Query';
+    morphoVaultPositions: {
+        __typename?: 'MorphoVaultPositionPage';
+        items: Array<{
+            __typename?: 'MorphoVaultPosition';
+            vault: {
+                __typename?: 'MorphoVault';
+                vaultAddress: `0x${string}`;
+                chain: {
+                    __typename?: 'Chain';
+                    id: 80094;
+                };
+            };
+            supplyAmount: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            walletUnderlyingAssetHolding: {
+                __typename?: 'TokenHolding';
+                balance: {
+                    __typename?: 'TokenAmount';
+                    raw: string | bigint;
+                    formatted: string;
+                    usd: number | null;
+                };
+            } | null;
+        } | null>;
+    };
+};
+type MarketPositionsQueryVariables = Exact<{
+    chainIds: Array<Scalars['ChainId']['input']> | Scalars['ChainId']['input'];
+    marketIds: Array<Scalars['Hex']['input']> | Scalars['Hex']['input'];
+    accountAddress: Scalars['Address']['input'];
+}>;
+type MarketPositionsQuery = {
+    __typename?: 'Query';
+    morphoMarketPositions: {
+        __typename?: 'MorphoMarketPositionPage';
+        items: Array<{
+            __typename?: 'MorphoMarketPosition';
+            market: {
+                __typename?: 'MorphoMarket';
+                marketId: `0x${string}`;
+                chain: {
+                    __typename?: 'Chain';
+                    id: 80094;
+                };
+            };
+            collateralAmount: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            } | null;
+            borrowAmount: {
+                __typename?: 'TokenAmount';
+                raw: string | bigint;
+                formatted: string;
+                usd: number | null;
+            };
+            ltv: {
+                __typename?: 'OnchainAmount';
+                formatted: string;
+            } | null;
+            walletLoanAssetHolding: {
+                __typename?: 'TokenHolding';
+                balance: {
+                    __typename?: 'TokenAmount';
+                    raw: string | bigint;
+                    formatted: string;
+                    usd: number | null;
+                };
+            };
+            walletCollateralAssetHolding: {
+                __typename?: 'TokenHolding';
+                balance: {
+                    __typename?: 'TokenAmount';
+                    raw: string | bigint;
+                    formatted: string;
+                    usd: number | null;
+                };
+            } | null;
+        } | null>;
+    };
+};
+type SupportedMarketIdsQueryVariables = Exact<{
+    chainIds: Array<Scalars['ChainId']['input']> | Scalars['ChainId']['input'];
+    vaultAddresses: Array<Scalars['Address']['input']> | Scalars['Address']['input'];
+}>;
+type SupportedMarketIdsQuery = {
+    __typename?: 'Query';
+    morphoVaults: {
+        __typename?: 'MorphoVaultPage';
+        items: Array<{
+            __typename?: 'MorphoVault';
+            chain: {
+                __typename?: 'Chain';
+                id: 80094;
+            };
+            marketAllocations: Array<{
+                __typename?: 'MorphoVaultMarketAllocation';
+                market: {
+                    __typename?: 'MorphoMarket';
+                    marketId: `0x${string}`;
+                };
+            }>;
+        } | null>;
+    };
+};
+type GetAccountIsOfacSanctionedQueryVariables = Exact<{
+    address: Scalars['Address']['input'];
+}>;
+type GetAccountIsOfacSanctionedQuery = {
+    __typename?: 'Query';
+    identity: {
+        __typename?: 'Identity';
+        isOfacSanctioned: boolean;
+    } | null;
+};
+declare const ChainInfoFragment: graphql.DocumentNode;
+declare const TokenInfoFragment: graphql.DocumentNode;
+declare const CuratorInfoFragment: graphql.DocumentNode;
+declare const ApyFragment: graphql.DocumentNode;
+declare const VaultSummaryFragment: graphql.DocumentNode;
+declare const MarketSummaryFragment: graphql.DocumentNode;
+declare const VaultSummaries: graphql.DocumentNode;
+declare const MarketSummaries: graphql.DocumentNode;
+/** Vault */
+type Vault = {
+    __typename?: 'Vault';
+    /** Underlying asset of the vault */
+    asset: Token;
+    /** Chain the vault is deployed on */
+    chain: Chain;
+    /** Description of the vault */
+    description: Maybe<Scalars['String']['output']>;
+    /** Name of the vault */
+    name: Scalars['String']['output'];
+    /** Protocol the vault is part of */
+    protocol: Protocol;
+    /** APY of the vault */
+    supplyApy: Apy;
+    /** Total amount of underlying assets supplied to the vault */
+    totalSupplied: TokenAmount;
+    /** Type of vault */
+    type: VaultType;
+    /** URL of the vault */
+    url: Scalars['String']['output'];
+    /** Address of the vault */
+    vaultAddress: Scalars['Address']['output'];
+};
+declare const Vault: graphql.DocumentNode;
+declare const Market: graphql.DocumentNode;
+declare const VaultPositions: graphql.DocumentNode;
+declare const MarketPositions: graphql.DocumentNode;
+declare const SupportedMarketIds: graphql.DocumentNode;
+declare const GetAccountIsOfacSanctioned: graphql.DocumentNode;
+interface PossibleTypesResultData {
+    possibleTypes: {
+        [key: string]: string[];
+    };
+}
+declare const result: PossibleTypesResultData;
+
+export { type AeraVault, type AeraVaultFilter, type AeraVaultPage, type AeraVaultPosition, type AeraVaultPositionFilter, type AeraVaultPositionPage, type Apy, ApyFragment, type ApyFragmentFragment, ApySide, type Chain, type ChainFilter, ChainInfoFragment, type ChainInfoFragmentFragment, type Curator, CuratorInfoFragment, type CuratorInfoFragmentFragment, type Exact, GetAccountIsOfacSanctioned, type GetAccountIsOfacSanctionedQuery, type GetAccountIsOfacSanctionedQueryVariables, type Identity, IdentityResolver, type IdentityResolverOutput, type Incremental, type InputMaybe, type MakeEmpty, type MakeMaybe, type MakeOptional, Market, MarketPositions, type MarketPositionsQuery, type MarketPositionsQueryVariables, type MarketQuery, type MarketQueryVariables, MarketSummaries, type MarketSummariesQuery, type MarketSummariesQueryVariables, MarketSummaryFragment, type MarketSummaryFragmentFragment, type Maybe, type MerklAccountReward, MerklAction, type MerklRewardInput, type MorphoIrm, type MorphoIrmCurvePoint, type MorphoMarket, type MorphoMarketFilter, type MorphoMarketHistorical, type MorphoMarketHistoricalEntry, type MorphoMarketPage, type MorphoMarketPosition, type MorphoMarketPositionFilter, type MorphoMarketPositionHistorical, type MorphoMarketPositionHistoricalEntry, type MorphoMarketPositionPage, type MorphoVault, type MorphoVaultFilter, type MorphoVaultHistorical, type MorphoVaultHistoricalEntry, type MorphoVaultMarketAllocation, type MorphoVaultMetadata, type MorphoVaultPage, type MorphoVaultPosition, type MorphoVaultPositionFilter, type MorphoVaultPositionHistorical, type MorphoVaultPositionHistoricalEntry, type MorphoVaultPositionPage, type OnchainAmount, type PageInfo, type PossibleTypesResultData, type Protocol, type Query, type QueryAeraVaultPositionsArgs, type QueryAeraVaultsArgs, type QueryChainsArgs, type QueryIdentitiesArgs, type QueryIdentityArgs, type QueryMerklAccountRewardsArgs, type QueryMorphoMarketPositionsArgs, type QueryMorphoMarketsArgs, type QueryMorphoVaultPositionsArgs, type QueryMorphoVaultsArgs, type QueryTokenHoldingsArgs, type QueryTokensArgs, type QueryVaultsArgs, type Reward, type Scalars, SupportedMarketIds, type SupportedMarketIdsQuery, type SupportedMarketIdsQueryVariables, type Token, type TokenAmount, TokenCategory, type TokenHistorical, type TokenHistoricalEntry, type TokenHolding, type TokenHoldingInput, TokenInfoFragment, type TokenInfoFragmentFragment, type TokenInput, Vault, type VaultInput, VaultPositions, type VaultPositionsQuery, type VaultPositionsQueryVariables, VaultProtocol, type VaultQuery, type VaultQueryVariables, VaultSummaries, type VaultSummariesQuery, type VaultSummariesQueryVariables, VaultSummaryFragment, type VaultSummaryFragmentFragment, VaultType, result as default };