@berachain/graphql 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/pol/subgraph.codegen.d.mts

@@ -0,0 +1,4671 @@
+import * as _apollo_client from '@apollo/client';
+
+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;
+    };
+    BigDecimal: {
+        input: any;
+        output: any;
+    };
+    BigInt: {
+        input: any;
+        output: any;
+    };
+    Bytes: {
+        input: any;
+        output: any;
+    };
+    Int8: {
+        input: any;
+        output: any;
+    };
+    Timestamp: {
+        input: any;
+        output: any;
+    };
+};
+type ActiveIncentive = {
+    __typename?: 'ActiveIncentive';
+    id: Scalars['Bytes']['output'];
+    incentiveRate?: Maybe<Scalars['BigDecimal']['output']>;
+    manager: Scalars['Bytes']['output'];
+    remainingAmount: Scalars['BigDecimal']['output'];
+    token: TokenInformation;
+    vault: Vault;
+};
+type ActiveIncentive_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<ActiveIncentive_Filter>>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    incentiveRate?: InputMaybe<Scalars['BigDecimal']['input']>;
+    incentiveRate_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    incentiveRate_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    incentiveRate_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    incentiveRate_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    incentiveRate_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    incentiveRate_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    incentiveRate_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    manager?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    manager_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_not?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<ActiveIncentive_Filter>>>;
+    remainingAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    remainingAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    remainingAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    remainingAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    remainingAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    remainingAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    remainingAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    remainingAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    token_?: InputMaybe<TokenInformation_Filter>;
+    token_contains?: InputMaybe<Scalars['String']['input']>;
+    token_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_gt?: InputMaybe<Scalars['String']['input']>;
+    token_gte?: InputMaybe<Scalars['String']['input']>;
+    token_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_lt?: InputMaybe<Scalars['String']['input']>;
+    token_lte?: InputMaybe<Scalars['String']['input']>;
+    token_not?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+    vault_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_gt?: InputMaybe<Scalars['String']['input']>;
+    vault_gte?: InputMaybe<Scalars['String']['input']>;
+    vault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_lt?: InputMaybe<Scalars['String']['input']>;
+    vault_lte?: InputMaybe<Scalars['String']['input']>;
+    vault_not?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum ActiveIncentive_OrderBy {
+    Id = "id",
+    IncentiveRate = "incentiveRate",
+    Manager = "manager",
+    RemainingAmount = "remainingAmount",
+    Token = "token",
+    TokenAddress = "token__address",
+    TokenDecimals = "token__decimals",
+    TokenId = "token__id",
+    TokenName = "token__name",
+    TokenSymbol = "token__symbol",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+declare enum Aggregation_Interval {
+    Day = "day",
+    Hour = "hour"
+}
+type BlockChangedFilter = {
+    number_gte: Scalars['Int']['input'];
+};
+/**
+ * Timeseries data for the amount of BGT awarded to a Validator for proposing a block (Distributor -> Validator)
+ * `BGTEmitted` is the amount of BGT that was awarded to the Validator, but must redistribute to a Vault based on the the Validator's RewardAllocation
+ * `BGTEarned` is the amount of BGT that was awarded to and kept by the Validator
+ *
+ */
+type BlockReward = {
+    __typename?: 'BlockReward';
+    blockNumber: Scalars['BigInt']['output'];
+    count: Scalars['BigInt']['output'];
+    distributedBGTAmount: Scalars['BigDecimal']['output'];
+    earnedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    nextTimestamp: Scalars['BigInt']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    txHash: Scalars['Bytes']['output'];
+    validator: Validator;
+};
+/**
+ * Aggregation for the amount of BGT awarded to a Validator for proposing a block across the chain (Distributor -> Validator)
+ *
+ */
+type BlockRewardStats = {
+    __typename?: 'BlockRewardStats';
+    allTimeDistributedBGTAmount: Scalars['BigDecimal']['output'];
+    allTimeEarnedBGTAmount: Scalars['BigDecimal']['output'];
+    blockCount: Scalars['BigInt']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    totalDistributedBGTAmount: Scalars['BigDecimal']['output'];
+    totalEarnedBGTAmount: Scalars['BigDecimal']['output'];
+};
+type BlockRewardStatsByValidator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<BlockRewardStatsByValidator_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<BlockRewardStatsByValidator_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+};
+type BlockRewardStats_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<BlockRewardStats_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<BlockRewardStats_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+};
+type BlockReward_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<BlockReward_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    count?: InputMaybe<Scalars['BigInt']['input']>;
+    count_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    count_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    count_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    count_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    count_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    count_not?: InputMaybe<Scalars['BigInt']['input']>;
+    count_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    distributedBGTAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    distributedBGTAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    earnedBGTAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    earnedBGTAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    earnedBGTAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    earnedBGTAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    earnedBGTAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    earnedBGTAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    earnedBGTAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    earnedBGTAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    id_not?: InputMaybe<Scalars['Int8']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    nextTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    nextTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<BlockReward_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum BlockReward_OrderBy {
+    BlockNumber = "blockNumber",
+    Count = "count",
+    DistributedBgtAmount = "distributedBGTAmount",
+    EarnedBgtAmount = "earnedBGTAmount",
+    Id = "id",
+    NextTimestamp = "nextTimestamp",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+/**
+ * Aggregation for the number of blocks proposed on the chain globally
+ * There is no way to track which validator proposed the block based on the block itself
+ * BlockReward is used as a proxy for the number of blocks proposed on the chain
+ * `blockCount` is the number of blocks that we have processed rewards for in the interval (hour/day)
+ *
+ */
+type BlockStats = {
+    __typename?: 'BlockStats';
+    blockCount: Scalars['BigInt']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+};
+/**
+ * Aggregation for the number of blocks proposed by a Validator
+ * There is no way to track which Validator proposed the block based on the block itself
+ * BlockReward is used as a proxy for number of blocks proposed by a validator
+ * `blockCount` is the number of blocks that we have processed rewards for that validator
+ * `allTimeBlockCount` is the number of blocks that we have processed rewards for that validator over its lifetime
+ *
+ */
+type BlockStatsByValidator = {
+    __typename?: 'BlockStatsByValidator';
+    allTimeBlockCount: Scalars['BigInt']['output'];
+    blockCount: Scalars['BigInt']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    validator: Validator;
+};
+type BlockStatsByValidator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<BlockStatsByValidator_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<BlockStatsByValidator_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+};
+type BlockStats_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<BlockStats_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<BlockStats_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+};
+type Block_Height = {
+    hash?: InputMaybe<Scalars['Bytes']['input']>;
+    number?: InputMaybe<Scalars['Int']['input']>;
+    number_gte?: InputMaybe<Scalars['Int']['input']>;
+};
+/**
+ * Timeseries data for the amount of BGT boosted to a Validator (User -> Validator)
+ *
+ */
+type Boost = {
+    __typename?: 'Boost';
+    blockNumber: Scalars['BigInt']['output'];
+    boostAmount: Scalars['BigDecimal']['output'];
+    dropBoostAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    netAmount: Scalars['BigDecimal']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    txHash: Scalars['Bytes']['output'];
+    user: Scalars['Bytes']['output'];
+    validator: Validator;
+};
+type BoostByValidator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<BoostByValidator_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<BoostByValidator_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+};
+type Boost_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<Boost_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    boostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    boostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    boostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    boostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    boostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    boostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    boostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    boostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    dropBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    dropBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    dropBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    dropBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    dropBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    dropBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    dropBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    dropBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    id_not?: InputMaybe<Scalars['Int8']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    netAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    netAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    netAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    netAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    netAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    netAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    netAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    netAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<Boost_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    user?: InputMaybe<Scalars['Bytes']['input']>;
+    user_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    user_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum Boost_OrderBy {
+    BlockNumber = "blockNumber",
+    BoostAmount = "boostAmount",
+    DropBoostAmount = "dropBoostAmount",
+    Id = "id",
+    NetAmount = "netAmount",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    User = "user",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+type GlobalInfo_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<GlobalInfo_Filter>>>;
+    baseRewardRate?: InputMaybe<Scalars['BigDecimal']['input']>;
+    baseRewardRate_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    baseRewardRate_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    baseRewardRate_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    baseRewardRate_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    baseRewardRate_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    baseRewardRate_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    baseRewardRate_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    maxNumWeightsPerRewardAllocation?: InputMaybe<Scalars['BigInt']['input']>;
+    maxNumWeightsPerRewardAllocation_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    maxNumWeightsPerRewardAllocation_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    maxNumWeightsPerRewardAllocation_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    maxNumWeightsPerRewardAllocation_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    maxNumWeightsPerRewardAllocation_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    maxNumWeightsPerRewardAllocation_not?: InputMaybe<Scalars['BigInt']['input']>;
+    maxNumWeightsPerRewardAllocation_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    minBoostedRewardRate?: InputMaybe<Scalars['BigDecimal']['input']>;
+    minBoostedRewardRate_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    minBoostedRewardRate_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    minBoostedRewardRate_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    minBoostedRewardRate_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    minBoostedRewardRate_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    minBoostedRewardRate_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    minBoostedRewardRate_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<GlobalInfo_Filter>>>;
+    rewardAllocationMaxWeightPerVault?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_?: InputMaybe<RewardAllocationMaxWeightHistory_Filter>;
+    rewardAllocationMaxWeightPerVault_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_gt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_gte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocationMaxWeightPerVault_lt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_lte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocationMaxWeightPerVault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationMaxWeightPerVault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardRate?: InputMaybe<Scalars['BigDecimal']['input']>;
+    rewardRate_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    rewardRate_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    rewardRate_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    rewardRate_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    rewardRate_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    rewardRate_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    rewardRate_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalActiveBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalActiveBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalActiveBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalActiveBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalActiveBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalActiveBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalActiveBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalActiveBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalBGTRedeemedAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalBGTRedeemedAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalBGTRedeemedAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalBGTRedeemedAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalBGTRedeemedAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalBGTRedeemedAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalBGTRedeemedAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalBGTRedeemedAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalDistributedAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalDistributedAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalDistributedAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalDistributedAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalDistributedAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalDistributedAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalDistributedAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalDistributedAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalQueuedBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalQueuedBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalQueuedDropBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedDropBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedDropBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedDropBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalQueuedDropBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedDropBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedDropBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    totalQueuedDropBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    totalValidatorsCount?: InputMaybe<Scalars['BigInt']['input']>;
+    totalValidatorsCount_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    totalValidatorsCount_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    totalValidatorsCount_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    totalValidatorsCount_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    totalValidatorsCount_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    totalValidatorsCount_not?: InputMaybe<Scalars['BigInt']['input']>;
+    totalValidatorsCount_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+};
+declare enum GlobalInfo_OrderBy {
+    BaseRewardRate = "baseRewardRate",
+    Id = "id",
+    MaxNumWeightsPerRewardAllocation = "maxNumWeightsPerRewardAllocation",
+    MinBoostedRewardRate = "minBoostedRewardRate",
+    RewardAllocationMaxWeightPerVault = "rewardAllocationMaxWeightPerVault",
+    RewardAllocationMaxWeightPerVaultBlockNumber = "rewardAllocationMaxWeightPerVault__blockNumber",
+    RewardAllocationMaxWeightPerVaultId = "rewardAllocationMaxWeightPerVault__id",
+    RewardAllocationMaxWeightPerVaultMaxWeightPerVault = "rewardAllocationMaxWeightPerVault__maxWeightPerVault",
+    RewardAllocationMaxWeightPerVaultTimestamp = "rewardAllocationMaxWeightPerVault__timestamp",
+    RewardAllocationMaxWeightPerVaultTxHash = "rewardAllocationMaxWeightPerVault__txHash",
+    RewardRate = "rewardRate",
+    TotalActiveBoostAmount = "totalActiveBoostAmount",
+    TotalBgtRedeemedAmount = "totalBGTRedeemedAmount",
+    TotalDistributedAmount = "totalDistributedAmount",
+    TotalQueuedBoostAmount = "totalQueuedBoostAmount",
+    TotalQueuedDropBoostAmount = "totalQueuedDropBoostAmount",
+    TotalValidatorsCount = "totalValidatorsCount"
+}
+/**
+ * Aggregation for all BGT distributed globally - total and by hour/day (Validator -> Vault)
+ *
+ */
+type GlobalRewardDistribution = {
+    __typename?: 'GlobalRewardDistribution';
+    allTimeDistributedBGTAmount: Scalars['BigDecimal']['output'];
+    distributedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+};
+type GlobalRewardDistribution_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<GlobalRewardDistribution_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<GlobalRewardDistribution_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+};
+/**
+ * Timeseries data for each Incentive distributed (Vault -> Validator)
+ *
+ */
+type IncentiveDistribution = {
+    __typename?: 'IncentiveDistribution';
+    blockNumber: Scalars['BigInt']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    toValidator: Scalars['Boolean']['output'];
+    token: TokenInformation;
+    tokenAmount: Scalars['BigDecimal']['output'];
+    txHash: Scalars['Bytes']['output'];
+    validator: Validator;
+    vault: Vault;
+};
+/**
+ * Aggregation for all incentives received by a Validator and an Incentive Token (Vault -> Validator)
+ *
+ */
+type IncentiveDistributionByValidator = {
+    __typename?: 'IncentiveDistributionByValidator';
+    allTimeReceivedTokenAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    receivedTokenAmount: Scalars['BigDecimal']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    token: TokenInformation;
+    validator: Validator;
+};
+type IncentiveDistributionByValidator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveDistributionByValidator_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveDistributionByValidator_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    token_?: InputMaybe<TokenInformation_Filter>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+};
+/**
+ * Aggregation for all incentives distributed by a Vault and an Incentive Token (Vault -> Validator)
+ *
+ */
+type IncentiveDistributionByVault = {
+    __typename?: 'IncentiveDistributionByVault';
+    allTimeDistributedTokenAmount: Scalars['BigDecimal']['output'];
+    distributedTokenAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    token: TokenInformation;
+    vault: Vault;
+};
+type IncentiveDistributionByVault_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveDistributionByVault_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveDistributionByVault_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    token_?: InputMaybe<TokenInformation_Filter>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+};
+type IncentiveDistribution_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveDistribution_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    id_not?: InputMaybe<Scalars['Int8']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveDistribution_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    toValidator?: InputMaybe<Scalars['Boolean']['input']>;
+    toValidator_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    toValidator_not?: InputMaybe<Scalars['Boolean']['input']>;
+    toValidator_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    tokenAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    tokenAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    tokenAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    tokenAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    tokenAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    tokenAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    tokenAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    tokenAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    token_?: InputMaybe<TokenInformation_Filter>;
+    token_contains?: InputMaybe<Scalars['String']['input']>;
+    token_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_gt?: InputMaybe<Scalars['String']['input']>;
+    token_gte?: InputMaybe<Scalars['String']['input']>;
+    token_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_lt?: InputMaybe<Scalars['String']['input']>;
+    token_lte?: InputMaybe<Scalars['String']['input']>;
+    token_not?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+    vault_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_gt?: InputMaybe<Scalars['String']['input']>;
+    vault_gte?: InputMaybe<Scalars['String']['input']>;
+    vault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_lt?: InputMaybe<Scalars['String']['input']>;
+    vault_lte?: InputMaybe<Scalars['String']['input']>;
+    vault_not?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum IncentiveDistribution_OrderBy {
+    BlockNumber = "blockNumber",
+    Id = "id",
+    Timestamp = "timestamp",
+    ToValidator = "toValidator",
+    Token = "token",
+    TokenAmount = "tokenAmount",
+    TokenAddress = "token__address",
+    TokenDecimals = "token__decimals",
+    TokenId = "token__id",
+    TokenName = "token__name",
+    TokenSymbol = "token__symbol",
+    TxHash = "txHash",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+type IncentiveFeeClaim = {
+    __typename?: 'IncentiveFeeClaim';
+    blockNumber: Scalars['BigInt']['output'];
+    caller: Scalars['Bytes']['output'];
+    id: Scalars['Int8']['output'];
+    payoutAmount: Scalars['BigDecimal']['output'];
+    recipient: Scalars['Bytes']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    txHash: Scalars['Bytes']['output'];
+};
+type IncentiveFeeClaimStats = {
+    __typename?: 'IncentiveFeeClaimStats';
+    allTimePayoutAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    totalPayoutAmount: Scalars['BigDecimal']['output'];
+};
+type IncentiveFeeClaimStats_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveFeeClaimStats_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveFeeClaimStats_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+};
+type IncentiveFeeClaim_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveFeeClaim_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    caller?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    caller_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_not?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    caller_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    id_not?: InputMaybe<Scalars['Int8']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveFeeClaim_Filter>>>;
+    payoutAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    payoutAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    payoutAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    payoutAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    payoutAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    payoutAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    payoutAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    payoutAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    recipient?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    recipient_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_not?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    recipient_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+};
+declare enum IncentiveFeeClaim_OrderBy {
+    BlockNumber = "blockNumber",
+    Caller = "caller",
+    Id = "id",
+    PayoutAmount = "payoutAmount",
+    Recipient = "recipient",
+    Timestamp = "timestamp",
+    TxHash = "txHash"
+}
+type IncentiveFeePayoutAmountHistory = {
+    __typename?: 'IncentiveFeePayoutAmountHistory';
+    blockNumber: Scalars['BigInt']['output'];
+    id: Scalars['Bytes']['output'];
+    newPayoutAmount: Scalars['BigDecimal']['output'];
+    oldPayoutAmount: Scalars['BigDecimal']['output'];
+    timestamp: Scalars['BigInt']['output'];
+    txHash: Scalars['Bytes']['output'];
+};
+type IncentiveFeePayoutAmountHistory_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveFeePayoutAmountHistory_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    newPayoutAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    newPayoutAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    newPayoutAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    newPayoutAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    newPayoutAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    newPayoutAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    newPayoutAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    newPayoutAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    oldPayoutAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    oldPayoutAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    oldPayoutAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    oldPayoutAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    oldPayoutAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    oldPayoutAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    oldPayoutAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    oldPayoutAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveFeePayoutAmountHistory_Filter>>>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+};
+declare enum IncentiveFeePayoutAmountHistory_OrderBy {
+    BlockNumber = "blockNumber",
+    Id = "id",
+    NewPayoutAmount = "newPayoutAmount",
+    OldPayoutAmount = "oldPayoutAmount",
+    Timestamp = "timestamp",
+    TxHash = "txHash"
+}
+/**
+ * Unique number of incentive tokens rewarded to a Validator
+ *
+ */
+type IncentiveTokensByValidator = {
+    __typename?: 'IncentiveTokensByValidator';
+    id: Scalars['String']['output'];
+    token: TokenInformation;
+    validator: Validator;
+};
+type IncentiveTokensByValidator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<IncentiveTokensByValidator_Filter>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    id_contains?: InputMaybe<Scalars['String']['input']>;
+    id_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    id_ends_with?: InputMaybe<Scalars['String']['input']>;
+    id_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    id_gt?: InputMaybe<Scalars['String']['input']>;
+    id_gte?: InputMaybe<Scalars['String']['input']>;
+    id_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    id_lt?: InputMaybe<Scalars['String']['input']>;
+    id_lte?: InputMaybe<Scalars['String']['input']>;
+    id_not?: InputMaybe<Scalars['String']['input']>;
+    id_not_contains?: InputMaybe<Scalars['String']['input']>;
+    id_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    id_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    id_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    id_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    id_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    id_starts_with?: InputMaybe<Scalars['String']['input']>;
+    id_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    or?: InputMaybe<Array<InputMaybe<IncentiveTokensByValidator_Filter>>>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    token_?: InputMaybe<TokenInformation_Filter>;
+    token_contains?: InputMaybe<Scalars['String']['input']>;
+    token_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_gt?: InputMaybe<Scalars['String']['input']>;
+    token_gte?: InputMaybe<Scalars['String']['input']>;
+    token_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_lt?: InputMaybe<Scalars['String']['input']>;
+    token_lte?: InputMaybe<Scalars['String']['input']>;
+    token_not?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum IncentiveTokensByValidator_OrderBy {
+    Id = "id",
+    Token = "token",
+    TokenAddress = "token__address",
+    TokenDecimals = "token__decimals",
+    TokenId = "token__id",
+    TokenName = "token__name",
+    TokenSymbol = "token__symbol",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+/** Defines the order direction, either ascending or descending */
+declare enum OrderDirection {
+    Asc = "asc",
+    Desc = "desc"
+}
+type Query = {
+    __typename?: 'Query';
+    /** Access to subgraph metadata */
+    _meta?: Maybe<_Meta_>;
+    activeIncentive?: Maybe<ActiveIncentive>;
+    activeIncentives: Array<ActiveIncentive>;
+    blockReward?: Maybe<BlockReward>;
+    /** Collection of aggregated `BlockRewardStatsByValidator` values */
+    blockRewardStatsByValidators: Array<BlockRewardStatsByValidator>;
+    /** Collection of aggregated `BlockRewardStats` values */
+    blockRewardStats_collection: Array<BlockRewardStats>;
+    blockRewards: Array<BlockReward>;
+    /** Collection of aggregated `BlockStatsByValidator` values */
+    blockStatsByValidators: Array<BlockStatsByValidator>;
+    /** Collection of aggregated `BlockStats` values */
+    blockStats_collection: Array<BlockStats>;
+    boost?: Maybe<Boost>;
+    /** Collection of aggregated `BoostByValidator` values */
+    boostByValidators: Array<BoostByValidator>;
+    boosts: Array<Boost>;
+    globalInfo?: Maybe<GlobalInfo>;
+    globalInfos: Array<GlobalInfo>;
+    /** Collection of aggregated `GlobalRewardDistribution` values */
+    globalRewardDistributions: Array<GlobalRewardDistribution>;
+    incentiveDistribution?: Maybe<IncentiveDistribution>;
+    /** Collection of aggregated `IncentiveDistributionByValidator` values */
+    incentiveDistributionByValidators: Array<IncentiveDistributionByValidator>;
+    /** Collection of aggregated `IncentiveDistributionByVault` values */
+    incentiveDistributionByVaults: Array<IncentiveDistributionByVault>;
+    incentiveDistributions: Array<IncentiveDistribution>;
+    incentiveFeeClaim?: Maybe<IncentiveFeeClaim>;
+    /** Collection of aggregated `IncentiveFeeClaimStats` values */
+    incentiveFeeClaimStats_collection: Array<IncentiveFeeClaimStats>;
+    incentiveFeeClaims: Array<IncentiveFeeClaim>;
+    incentiveFeePayoutAmountHistories: Array<IncentiveFeePayoutAmountHistory>;
+    incentiveFeePayoutAmountHistory?: Maybe<IncentiveFeePayoutAmountHistory>;
+    incentiveTokensByValidator?: Maybe<IncentiveTokensByValidator>;
+    incentiveTokensByValidators: Array<IncentiveTokensByValidator>;
+    rewardAllocation?: Maybe<RewardAllocation>;
+    rewardAllocationActivation?: Maybe<RewardAllocationActivation>;
+    rewardAllocationActivations: Array<RewardAllocationActivation>;
+    rewardAllocationMaxWeightHistories: Array<RewardAllocationMaxWeightHistory>;
+    rewardAllocationMaxWeightHistory?: Maybe<RewardAllocationMaxWeightHistory>;
+    rewardAllocationQueue?: Maybe<RewardAllocationQueue>;
+    rewardAllocationQueues: Array<RewardAllocationQueue>;
+    rewardAllocationWeight?: Maybe<RewardAllocationWeight>;
+    rewardAllocationWeights: Array<RewardAllocationWeight>;
+    rewardAllocations: Array<RewardAllocation>;
+    rewardDistribution?: Maybe<RewardDistribution>;
+    /** Collection of aggregated `RewardDistributionByVault` values */
+    rewardDistributionByVaults: Array<RewardDistributionByVault>;
+    rewardDistributions: Array<RewardDistribution>;
+    /** Collection of aggregated `RewardsDistributionByValidator` values */
+    rewardsDistributionByValidators: Array<RewardsDistributionByValidator>;
+    tokenInformation?: Maybe<TokenInformation>;
+    tokenInformations: Array<TokenInformation>;
+    userBoost?: Maybe<UserBoost>;
+    userBoosts: Array<UserBoost>;
+    userFeeHistories: Array<UserFeeHistory>;
+    userFeeHistory?: Maybe<UserFeeHistory>;
+    userVaultStake?: Maybe<UserVaultStake>;
+    userVaultStakes: Array<UserVaultStake>;
+    validator?: Maybe<Validator>;
+    validatorCommissionHistories: Array<ValidatorCommissionHistory>;
+    validatorCommissionHistory?: Maybe<ValidatorCommissionHistory>;
+    validators: Array<Validator>;
+    vault?: Maybe<Vault>;
+    vaults: Array<Vault>;
+    whitelistedToken?: Maybe<WhitelistedToken>;
+    whitelistedTokens: Array<WhitelistedToken>;
+};
+type Query_MetaArgs = {
+    block?: InputMaybe<Block_Height>;
+};
+type QueryActiveIncentiveArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryActiveIncentivesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<ActiveIncentive_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<ActiveIncentive_Filter>;
+};
+type QueryBlockRewardArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryBlockRewardStatsByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockRewardStatsByValidator_Filter>;
+};
+type QueryBlockRewardStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockRewardStats_Filter>;
+};
+type QueryBlockRewardsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<BlockReward_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockReward_Filter>;
+};
+type QueryBlockStatsByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockStatsByValidator_Filter>;
+};
+type QueryBlockStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockStats_Filter>;
+};
+type QueryBoostArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryBoostByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BoostByValidator_Filter>;
+};
+type QueryBoostsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Boost_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Boost_Filter>;
+};
+type QueryGlobalInfoArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryGlobalInfosArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<GlobalInfo_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<GlobalInfo_Filter>;
+};
+type QueryGlobalRewardDistributionsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<GlobalRewardDistribution_Filter>;
+};
+type QueryIncentiveDistributionArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryIncentiveDistributionByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistributionByValidator_Filter>;
+};
+type QueryIncentiveDistributionByVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistributionByVault_Filter>;
+};
+type QueryIncentiveDistributionsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistribution_Filter>;
+};
+type QueryIncentiveFeeClaimArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryIncentiveFeeClaimStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveFeeClaimStats_Filter>;
+};
+type QueryIncentiveFeeClaimsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveFeeClaim_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveFeeClaim_Filter>;
+};
+type QueryIncentiveFeePayoutAmountHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveFeePayoutAmountHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveFeePayoutAmountHistory_Filter>;
+};
+type QueryIncentiveFeePayoutAmountHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryIncentiveTokensByValidatorArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryIncentiveTokensByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveTokensByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveTokensByValidator_Filter>;
+};
+type QueryRewardAllocationArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryRewardAllocationActivationArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryRewardAllocationActivationsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationActivation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationActivation_Filter>;
+};
+type QueryRewardAllocationMaxWeightHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationMaxWeightHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationMaxWeightHistory_Filter>;
+};
+type QueryRewardAllocationMaxWeightHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryRewardAllocationQueueArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryRewardAllocationQueuesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationQueue_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationQueue_Filter>;
+};
+type QueryRewardAllocationWeightArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryRewardAllocationWeightsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationWeight_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationWeight_Filter>;
+};
+type QueryRewardAllocationsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocation_Filter>;
+};
+type QueryRewardDistributionArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryRewardDistributionByVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardDistributionByVault_Filter>;
+};
+type QueryRewardDistributionsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardDistribution_Filter>;
+};
+type QueryRewardsDistributionByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardsDistributionByValidator_Filter>;
+};
+type QueryTokenInformationArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryTokenInformationsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<TokenInformation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<TokenInformation_Filter>;
+};
+type QueryUserBoostArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryUserBoostsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserBoost_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<UserBoost_Filter>;
+};
+type QueryUserFeeHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserFeeHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<UserFeeHistory_Filter>;
+};
+type QueryUserFeeHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryUserVaultStakeArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryUserVaultStakesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserVaultStake_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<UserVaultStake_Filter>;
+};
+type QueryValidatorArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryValidatorCommissionHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<ValidatorCommissionHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<ValidatorCommissionHistory_Filter>;
+};
+type QueryValidatorCommissionHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Validator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Validator_Filter>;
+};
+type QueryVaultArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Vault_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Vault_Filter>;
+};
+type QueryWhitelistedTokenArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type QueryWhitelistedTokensArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<WhitelistedToken_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<WhitelistedToken_Filter>;
+};
+/**
+ * RewardAllocation of a Validator
+ * - DefaultRewardAllocation is the only one that is linked to multiple Validators
+ * - DefaultRewardAllocation has a fixed ID of DEFAULT_REWARD_ALLOCATION_ID defined in `constant.ts` (0x0)
+ * - Actual weights are defined by RewardAllocationWeight
+ * - isDefault indicates that a RewardAllocation is or was a DefaultRewardAllocation
+ * - When DefaultRewardAllocation changes, a new RewardAllocation with a new ID is created to kept history and
+ * the new DefaultRewardAllocation will still have DEFAULT_REWARD_ALLOCATION_ID as its ID
+ * - isActive indicates that a RewardAllocation is currently being used by a Validator and not replaced
+ *
+ */
+type RewardAllocation = {
+    __typename?: 'RewardAllocation';
+    activatableAtBlock: Scalars['BigInt']['output'];
+    activations?: Maybe<Array<RewardAllocationActivation>>;
+    id: Scalars['Bytes']['output'];
+    isActive: Scalars['Boolean']['output'];
+    isDefault: Scalars['Boolean']['output'];
+    queues?: Maybe<Array<RewardAllocationQueue>>;
+    weights: Array<RewardAllocationWeight>;
+};
+/**
+ * RewardAllocation of a Validator
+ * - DefaultRewardAllocation is the only one that is linked to multiple Validators
+ * - DefaultRewardAllocation has a fixed ID of DEFAULT_REWARD_ALLOCATION_ID defined in `constant.ts` (0x0)
+ * - Actual weights are defined by RewardAllocationWeight
+ * - isDefault indicates that a RewardAllocation is or was a DefaultRewardAllocation
+ * - When DefaultRewardAllocation changes, a new RewardAllocation with a new ID is created to kept history and
+ * the new DefaultRewardAllocation will still have DEFAULT_REWARD_ALLOCATION_ID as its ID
+ * - isActive indicates that a RewardAllocation is currently being used by a Validator and not replaced
+ *
+ */
+type RewardAllocationActivationsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationActivation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<RewardAllocationActivation_Filter>;
+};
+/**
+ * RewardAllocation of a Validator
+ * - DefaultRewardAllocation is the only one that is linked to multiple Validators
+ * - DefaultRewardAllocation has a fixed ID of DEFAULT_REWARD_ALLOCATION_ID defined in `constant.ts` (0x0)
+ * - Actual weights are defined by RewardAllocationWeight
+ * - isDefault indicates that a RewardAllocation is or was a DefaultRewardAllocation
+ * - When DefaultRewardAllocation changes, a new RewardAllocation with a new ID is created to kept history and
+ * the new DefaultRewardAllocation will still have DEFAULT_REWARD_ALLOCATION_ID as its ID
+ * - isActive indicates that a RewardAllocation is currently being used by a Validator and not replaced
+ *
+ */
+type RewardAllocationQueuesArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationQueue_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<RewardAllocationQueue_Filter>;
+};
+/**
+ * RewardAllocation of a Validator
+ * - DefaultRewardAllocation is the only one that is linked to multiple Validators
+ * - DefaultRewardAllocation has a fixed ID of DEFAULT_REWARD_ALLOCATION_ID defined in `constant.ts` (0x0)
+ * - Actual weights are defined by RewardAllocationWeight
+ * - isDefault indicates that a RewardAllocation is or was a DefaultRewardAllocation
+ * - When DefaultRewardAllocation changes, a new RewardAllocation with a new ID is created to kept history and
+ * the new DefaultRewardAllocation will still have DEFAULT_REWARD_ALLOCATION_ID as its ID
+ * - isActive indicates that a RewardAllocation is currently being used by a Validator and not replaced
+ *
+ */
+type RewardAllocationWeightsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationWeight_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<RewardAllocationWeight_Filter>;
+};
+/**
+ * RewardAllocationActivation contains data when a Validator's RewardAllocation is activated
+ *
+ */
+type RewardAllocationActivation = {
+    __typename?: 'RewardAllocationActivation';
+    blockNumber: Scalars['BigInt']['output'];
+    id: Scalars['Bytes']['output'];
+    rewardAllocation?: Maybe<RewardAllocation>;
+    timestamp: Scalars['BigInt']['output'];
+    txHash: Scalars['Bytes']['output'];
+    validator: Validator;
+};
+type RewardAllocationActivation_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardAllocationActivation_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<RewardAllocationActivation_Filter>>>;
+    rewardAllocation?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_?: InputMaybe<RewardAllocation_Filter>;
+    rewardAllocation_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_gt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_gte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocation_lt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_lte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocation_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum RewardAllocationActivation_OrderBy {
+    BlockNumber = "blockNumber",
+    Id = "id",
+    RewardAllocation = "rewardAllocation",
+    RewardAllocationActivatableAtBlock = "rewardAllocation__activatableAtBlock",
+    RewardAllocationId = "rewardAllocation__id",
+    RewardAllocationIsActive = "rewardAllocation__isActive",
+    RewardAllocationIsDefault = "rewardAllocation__isDefault",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+/**
+ * Historical max weight per vault
+ *
+ */
+type RewardAllocationMaxWeightHistory = {
+    __typename?: 'RewardAllocationMaxWeightHistory';
+    blockNumber: Scalars['BigInt']['output'];
+    id: Scalars['Bytes']['output'];
+    maxWeightPerVault: Scalars['BigInt']['output'];
+    timestamp: Scalars['BigInt']['output'];
+    txHash: Scalars['Bytes']['output'];
+};
+type RewardAllocationMaxWeightHistory_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardAllocationMaxWeightHistory_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    maxWeightPerVault?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVault_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVault_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVault_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    maxWeightPerVault_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVault_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVault_not?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVault_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<RewardAllocationMaxWeightHistory_Filter>>>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+};
+declare enum RewardAllocationMaxWeightHistory_OrderBy {
+    BlockNumber = "blockNumber",
+    Id = "id",
+    MaxWeightPerVault = "maxWeightPerVault",
+    Timestamp = "timestamp",
+    TxHash = "txHash"
+}
+/**
+ * RewardAllocationQueue contains data when a Validator's RewardAllocation is queued
+ *
+ */
+type RewardAllocationQueue = {
+    __typename?: 'RewardAllocationQueue';
+    blockNumber: Scalars['BigInt']['output'];
+    id: Scalars['Bytes']['output'];
+    rewardAllocation: RewardAllocation;
+    timestamp: Scalars['BigInt']['output'];
+    txHash: Scalars['Bytes']['output'];
+    validator: Validator;
+};
+type RewardAllocationQueue_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardAllocationQueue_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<RewardAllocationQueue_Filter>>>;
+    rewardAllocation?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_?: InputMaybe<RewardAllocation_Filter>;
+    rewardAllocation_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_gt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_gte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocation_lt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_lte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocation_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum RewardAllocationQueue_OrderBy {
+    BlockNumber = "blockNumber",
+    Id = "id",
+    RewardAllocation = "rewardAllocation",
+    RewardAllocationActivatableAtBlock = "rewardAllocation__activatableAtBlock",
+    RewardAllocationId = "rewardAllocation__id",
+    RewardAllocationIsActive = "rewardAllocation__isActive",
+    RewardAllocationIsDefault = "rewardAllocation__isDefault",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+/**
+ * Weights of a Validator's RewardAllocation in numerator (over /10000)
+ * The weight or percentage (% - percentageNumerator/10000) of rewards allocated to a Vault
+ *
+ */
+type RewardAllocationWeight = {
+    __typename?: 'RewardAllocationWeight';
+    id: Scalars['Bytes']['output'];
+    percentageNumerator: Scalars['BigInt']['output'];
+    rewardAllocation: RewardAllocation;
+    vault: Vault;
+};
+type RewardAllocationWeight_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardAllocationWeight_Filter>>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<RewardAllocationWeight_Filter>>>;
+    percentageNumerator?: InputMaybe<Scalars['BigInt']['input']>;
+    percentageNumerator_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    percentageNumerator_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    percentageNumerator_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    percentageNumerator_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    percentageNumerator_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    percentageNumerator_not?: InputMaybe<Scalars['BigInt']['input']>;
+    percentageNumerator_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    rewardAllocation?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_?: InputMaybe<RewardAllocation_Filter>;
+    rewardAllocation_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_gt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_gte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocation_lt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_lte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocation_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocation_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+    vault_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_gt?: InputMaybe<Scalars['String']['input']>;
+    vault_gte?: InputMaybe<Scalars['String']['input']>;
+    vault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_lt?: InputMaybe<Scalars['String']['input']>;
+    vault_lte?: InputMaybe<Scalars['String']['input']>;
+    vault_not?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum RewardAllocationWeight_OrderBy {
+    Id = "id",
+    PercentageNumerator = "percentageNumerator",
+    RewardAllocation = "rewardAllocation",
+    RewardAllocationActivatableAtBlock = "rewardAllocation__activatableAtBlock",
+    RewardAllocationId = "rewardAllocation__id",
+    RewardAllocationIsActive = "rewardAllocation__isActive",
+    RewardAllocationIsDefault = "rewardAllocation__isDefault",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+type RewardAllocation_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    activatableAtBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    activatableAtBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    activatableAtBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    activatableAtBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    activatableAtBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    activatableAtBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    activatableAtBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    activatableAtBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    activations_?: InputMaybe<RewardAllocationActivation_Filter>;
+    and?: InputMaybe<Array<InputMaybe<RewardAllocation_Filter>>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    isActive?: InputMaybe<Scalars['Boolean']['input']>;
+    isActive_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    isActive_not?: InputMaybe<Scalars['Boolean']['input']>;
+    isActive_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    isDefault?: InputMaybe<Scalars['Boolean']['input']>;
+    isDefault_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    isDefault_not?: InputMaybe<Scalars['Boolean']['input']>;
+    isDefault_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<RewardAllocation_Filter>>>;
+    queues_?: InputMaybe<RewardAllocationQueue_Filter>;
+    weights_?: InputMaybe<RewardAllocationWeight_Filter>;
+};
+declare enum RewardAllocation_OrderBy {
+    ActivatableAtBlock = "activatableAtBlock",
+    Activations = "activations",
+    Id = "id",
+    IsActive = "isActive",
+    IsDefault = "isDefault",
+    Queues = "queues",
+    Weights = "weights"
+}
+/**
+ * Timeseries data for the amount of BGT distributed by a Validator (Validator -> Vault)
+ *
+ */
+type RewardDistribution = {
+    __typename?: 'RewardDistribution';
+    blockNumber: Scalars['BigInt']['output'];
+    distributedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    nextTimestamp: Scalars['BigInt']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    txHash: Scalars['Bytes']['output'];
+    validator: Validator;
+    vault: Vault;
+};
+/**
+ * Aggregation for all BGT recieved by a Vault - total and by hour/day (Validator -> Vault)
+ *
+ */
+type RewardDistributionByVault = {
+    __typename?: 'RewardDistributionByVault';
+    allTimeReceivedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    receivedBGTAmount: Scalars['BigDecimal']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    vault: Vault;
+};
+type RewardDistributionByVault_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardDistributionByVault_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<RewardDistributionByVault_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+};
+type RewardDistribution_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardDistribution_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    distributedBGTAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    distributedBGTAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    distributedBGTAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    id_not?: InputMaybe<Scalars['Int8']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    nextTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    nextTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    nextTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<RewardDistribution_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+    vault_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_gt?: InputMaybe<Scalars['String']['input']>;
+    vault_gte?: InputMaybe<Scalars['String']['input']>;
+    vault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_lt?: InputMaybe<Scalars['String']['input']>;
+    vault_lte?: InputMaybe<Scalars['String']['input']>;
+    vault_not?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum RewardDistribution_OrderBy {
+    BlockNumber = "blockNumber",
+    DistributedBgtAmount = "distributedBGTAmount",
+    Id = "id",
+    NextTimestamp = "nextTimestamp",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+/**
+ * Aggregation for all BGT distributed by a Validator - total and by hour/day (Validator -> Vault)
+ *
+ */
+type RewardsDistributionByValidator = {
+    __typename?: 'RewardsDistributionByValidator';
+    allTimeDistributedBGTAmount: Scalars['BigDecimal']['output'];
+    distributedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    validator: Validator;
+};
+type RewardsDistributionByValidator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<RewardsDistributionByValidator_Filter>>>;
+    id?: InputMaybe<Scalars['Int8']['input']>;
+    id_gt?: InputMaybe<Scalars['Int8']['input']>;
+    id_gte?: InputMaybe<Scalars['Int8']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Int8']['input']>>;
+    id_lt?: InputMaybe<Scalars['Int8']['input']>;
+    id_lte?: InputMaybe<Scalars['Int8']['input']>;
+    or?: InputMaybe<Array<InputMaybe<RewardsDistributionByValidator_Filter>>>;
+    timestamp?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['Timestamp']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['Timestamp']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['Timestamp']['input']>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+};
+type Subscription = {
+    __typename?: 'Subscription';
+    /** Access to subgraph metadata */
+    _meta?: Maybe<_Meta_>;
+    activeIncentive?: Maybe<ActiveIncentive>;
+    activeIncentives: Array<ActiveIncentive>;
+    blockReward?: Maybe<BlockReward>;
+    /** Collection of aggregated `BlockRewardStatsByValidator` values */
+    blockRewardStatsByValidators: Array<BlockRewardStatsByValidator>;
+    /** Collection of aggregated `BlockRewardStats` values */
+    blockRewardStats_collection: Array<BlockRewardStats>;
+    blockRewards: Array<BlockReward>;
+    /** Collection of aggregated `BlockStatsByValidator` values */
+    blockStatsByValidators: Array<BlockStatsByValidator>;
+    /** Collection of aggregated `BlockStats` values */
+    blockStats_collection: Array<BlockStats>;
+    boost?: Maybe<Boost>;
+    /** Collection of aggregated `BoostByValidator` values */
+    boostByValidators: Array<BoostByValidator>;
+    boosts: Array<Boost>;
+    globalInfo?: Maybe<GlobalInfo>;
+    globalInfos: Array<GlobalInfo>;
+    /** Collection of aggregated `GlobalRewardDistribution` values */
+    globalRewardDistributions: Array<GlobalRewardDistribution>;
+    incentiveDistribution?: Maybe<IncentiveDistribution>;
+    /** Collection of aggregated `IncentiveDistributionByValidator` values */
+    incentiveDistributionByValidators: Array<IncentiveDistributionByValidator>;
+    /** Collection of aggregated `IncentiveDistributionByVault` values */
+    incentiveDistributionByVaults: Array<IncentiveDistributionByVault>;
+    incentiveDistributions: Array<IncentiveDistribution>;
+    incentiveFeeClaim?: Maybe<IncentiveFeeClaim>;
+    /** Collection of aggregated `IncentiveFeeClaimStats` values */
+    incentiveFeeClaimStats_collection: Array<IncentiveFeeClaimStats>;
+    incentiveFeeClaims: Array<IncentiveFeeClaim>;
+    incentiveFeePayoutAmountHistories: Array<IncentiveFeePayoutAmountHistory>;
+    incentiveFeePayoutAmountHistory?: Maybe<IncentiveFeePayoutAmountHistory>;
+    incentiveTokensByValidator?: Maybe<IncentiveTokensByValidator>;
+    incentiveTokensByValidators: Array<IncentiveTokensByValidator>;
+    rewardAllocation?: Maybe<RewardAllocation>;
+    rewardAllocationActivation?: Maybe<RewardAllocationActivation>;
+    rewardAllocationActivations: Array<RewardAllocationActivation>;
+    rewardAllocationMaxWeightHistories: Array<RewardAllocationMaxWeightHistory>;
+    rewardAllocationMaxWeightHistory?: Maybe<RewardAllocationMaxWeightHistory>;
+    rewardAllocationQueue?: Maybe<RewardAllocationQueue>;
+    rewardAllocationQueues: Array<RewardAllocationQueue>;
+    rewardAllocationWeight?: Maybe<RewardAllocationWeight>;
+    rewardAllocationWeights: Array<RewardAllocationWeight>;
+    rewardAllocations: Array<RewardAllocation>;
+    rewardDistribution?: Maybe<RewardDistribution>;
+    /** Collection of aggregated `RewardDistributionByVault` values */
+    rewardDistributionByVaults: Array<RewardDistributionByVault>;
+    rewardDistributions: Array<RewardDistribution>;
+    /** Collection of aggregated `RewardsDistributionByValidator` values */
+    rewardsDistributionByValidators: Array<RewardsDistributionByValidator>;
+    tokenInformation?: Maybe<TokenInformation>;
+    tokenInformations: Array<TokenInformation>;
+    userBoost?: Maybe<UserBoost>;
+    userBoosts: Array<UserBoost>;
+    userFeeHistories: Array<UserFeeHistory>;
+    userFeeHistory?: Maybe<UserFeeHistory>;
+    userVaultStake?: Maybe<UserVaultStake>;
+    userVaultStakes: Array<UserVaultStake>;
+    validator?: Maybe<Validator>;
+    validatorCommissionHistories: Array<ValidatorCommissionHistory>;
+    validatorCommissionHistory?: Maybe<ValidatorCommissionHistory>;
+    validators: Array<Validator>;
+    vault?: Maybe<Vault>;
+    vaults: Array<Vault>;
+    whitelistedToken?: Maybe<WhitelistedToken>;
+    whitelistedTokens: Array<WhitelistedToken>;
+};
+type Subscription_MetaArgs = {
+    block?: InputMaybe<Block_Height>;
+};
+type SubscriptionActiveIncentiveArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionActiveIncentivesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<ActiveIncentive_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<ActiveIncentive_Filter>;
+};
+type SubscriptionBlockRewardArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionBlockRewardStatsByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockRewardStatsByValidator_Filter>;
+};
+type SubscriptionBlockRewardStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockRewardStats_Filter>;
+};
+type SubscriptionBlockRewardsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<BlockReward_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockReward_Filter>;
+};
+type SubscriptionBlockStatsByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockStatsByValidator_Filter>;
+};
+type SubscriptionBlockStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockStats_Filter>;
+};
+type SubscriptionBoostArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionBoostByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BoostByValidator_Filter>;
+};
+type SubscriptionBoostsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Boost_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Boost_Filter>;
+};
+type SubscriptionGlobalInfoArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionGlobalInfosArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<GlobalInfo_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<GlobalInfo_Filter>;
+};
+type SubscriptionGlobalRewardDistributionsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<GlobalRewardDistribution_Filter>;
+};
+type SubscriptionIncentiveDistributionArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionIncentiveDistributionByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistributionByValidator_Filter>;
+};
+type SubscriptionIncentiveDistributionByVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistributionByVault_Filter>;
+};
+type SubscriptionIncentiveDistributionsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistribution_Filter>;
+};
+type SubscriptionIncentiveFeeClaimArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionIncentiveFeeClaimStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveFeeClaimStats_Filter>;
+};
+type SubscriptionIncentiveFeeClaimsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveFeeClaim_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveFeeClaim_Filter>;
+};
+type SubscriptionIncentiveFeePayoutAmountHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveFeePayoutAmountHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveFeePayoutAmountHistory_Filter>;
+};
+type SubscriptionIncentiveFeePayoutAmountHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionIncentiveTokensByValidatorArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionIncentiveTokensByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveTokensByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveTokensByValidator_Filter>;
+};
+type SubscriptionRewardAllocationArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionRewardAllocationActivationArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionRewardAllocationActivationsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationActivation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationActivation_Filter>;
+};
+type SubscriptionRewardAllocationMaxWeightHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationMaxWeightHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationMaxWeightHistory_Filter>;
+};
+type SubscriptionRewardAllocationMaxWeightHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionRewardAllocationQueueArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionRewardAllocationQueuesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationQueue_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationQueue_Filter>;
+};
+type SubscriptionRewardAllocationWeightArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionRewardAllocationWeightsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationWeight_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocationWeight_Filter>;
+};
+type SubscriptionRewardAllocationsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardAllocation_Filter>;
+};
+type SubscriptionRewardDistributionArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionRewardDistributionByVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardDistributionByVault_Filter>;
+};
+type SubscriptionRewardDistributionsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardDistribution_Filter>;
+};
+type SubscriptionRewardsDistributionByValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<RewardsDistributionByValidator_Filter>;
+};
+type SubscriptionTokenInformationArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionTokenInformationsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<TokenInformation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<TokenInformation_Filter>;
+};
+type SubscriptionUserBoostArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionUserBoostsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserBoost_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<UserBoost_Filter>;
+};
+type SubscriptionUserFeeHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserFeeHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<UserFeeHistory_Filter>;
+};
+type SubscriptionUserFeeHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionUserVaultStakeArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionUserVaultStakesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserVaultStake_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<UserVaultStake_Filter>;
+};
+type SubscriptionValidatorArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionValidatorCommissionHistoriesArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<ValidatorCommissionHistory_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<ValidatorCommissionHistory_Filter>;
+};
+type SubscriptionValidatorCommissionHistoryArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionValidatorsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Validator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Validator_Filter>;
+};
+type SubscriptionVaultArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Vault_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<Vault_Filter>;
+};
+type SubscriptionWhitelistedTokenArgs = {
+    block?: InputMaybe<Block_Height>;
+    id: Scalars['ID']['input'];
+    subgraphError?: _SubgraphErrorPolicy_;
+};
+type SubscriptionWhitelistedTokensArgs = {
+    block?: InputMaybe<Block_Height>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<WhitelistedToken_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<WhitelistedToken_Filter>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformation = {
+    __typename?: 'TokenInformation';
+    activeIncentives?: Maybe<Array<ActiveIncentive>>;
+    address: Scalars['String']['output'];
+    decimals: Scalars['Int']['output'];
+    distributedIncentives?: Maybe<Array<IncentiveDistribution>>;
+    distributedIncentivesByVault?: Maybe<Array<IncentiveDistributionByVault>>;
+    id: Scalars['Bytes']['output'];
+    name: Scalars['String']['output'];
+    receivedValidators?: Maybe<Array<IncentiveTokensByValidator>>;
+    stakedVaults?: Maybe<Array<Vault>>;
+    symbol: Scalars['String']['output'];
+    whitelistedVaults?: Maybe<Array<WhitelistedToken>>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformationActiveIncentivesArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<ActiveIncentive_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<ActiveIncentive_Filter>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformationDistributedIncentivesArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IncentiveDistribution_Filter>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformationDistributedIncentivesByVaultArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IncentiveDistributionByVault_Filter>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformationReceivedValidatorsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveTokensByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IncentiveTokensByValidator_Filter>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformationStakedVaultsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Vault_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<Vault_Filter>;
+};
+/**
+ * Stores basic info for every token
+ *
+ */
+type TokenInformationWhitelistedVaultsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<WhitelistedToken_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<WhitelistedToken_Filter>;
+};
+type TokenInformation_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    activeIncentives_?: InputMaybe<ActiveIncentive_Filter>;
+    address?: InputMaybe<Scalars['String']['input']>;
+    address_contains?: InputMaybe<Scalars['String']['input']>;
+    address_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    address_ends_with?: InputMaybe<Scalars['String']['input']>;
+    address_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    address_gt?: InputMaybe<Scalars['String']['input']>;
+    address_gte?: InputMaybe<Scalars['String']['input']>;
+    address_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    address_lt?: InputMaybe<Scalars['String']['input']>;
+    address_lte?: InputMaybe<Scalars['String']['input']>;
+    address_not?: InputMaybe<Scalars['String']['input']>;
+    address_not_contains?: InputMaybe<Scalars['String']['input']>;
+    address_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    address_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    address_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    address_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    address_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    address_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    address_starts_with?: InputMaybe<Scalars['String']['input']>;
+    address_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    and?: InputMaybe<Array<InputMaybe<TokenInformation_Filter>>>;
+    decimals?: InputMaybe<Scalars['Int']['input']>;
+    decimals_gt?: InputMaybe<Scalars['Int']['input']>;
+    decimals_gte?: InputMaybe<Scalars['Int']['input']>;
+    decimals_in?: InputMaybe<Array<Scalars['Int']['input']>>;
+    decimals_lt?: InputMaybe<Scalars['Int']['input']>;
+    decimals_lte?: InputMaybe<Scalars['Int']['input']>;
+    decimals_not?: InputMaybe<Scalars['Int']['input']>;
+    decimals_not_in?: InputMaybe<Array<Scalars['Int']['input']>>;
+    distributedIncentivesByVault_?: InputMaybe<IncentiveDistributionByVault_Filter>;
+    distributedIncentives_?: InputMaybe<IncentiveDistribution_Filter>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    name_contains?: InputMaybe<Scalars['String']['input']>;
+    name_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    name_ends_with?: InputMaybe<Scalars['String']['input']>;
+    name_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    name_gt?: InputMaybe<Scalars['String']['input']>;
+    name_gte?: InputMaybe<Scalars['String']['input']>;
+    name_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    name_lt?: InputMaybe<Scalars['String']['input']>;
+    name_lte?: InputMaybe<Scalars['String']['input']>;
+    name_not?: InputMaybe<Scalars['String']['input']>;
+    name_not_contains?: InputMaybe<Scalars['String']['input']>;
+    name_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    name_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    name_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    name_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    name_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    name_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    name_starts_with?: InputMaybe<Scalars['String']['input']>;
+    name_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    or?: InputMaybe<Array<InputMaybe<TokenInformation_Filter>>>;
+    receivedValidators_?: InputMaybe<IncentiveTokensByValidator_Filter>;
+    stakedVaults_?: InputMaybe<Vault_Filter>;
+    symbol?: InputMaybe<Scalars['String']['input']>;
+    symbol_contains?: InputMaybe<Scalars['String']['input']>;
+    symbol_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    symbol_ends_with?: InputMaybe<Scalars['String']['input']>;
+    symbol_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    symbol_gt?: InputMaybe<Scalars['String']['input']>;
+    symbol_gte?: InputMaybe<Scalars['String']['input']>;
+    symbol_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    symbol_lt?: InputMaybe<Scalars['String']['input']>;
+    symbol_lte?: InputMaybe<Scalars['String']['input']>;
+    symbol_not?: InputMaybe<Scalars['String']['input']>;
+    symbol_not_contains?: InputMaybe<Scalars['String']['input']>;
+    symbol_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    symbol_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    symbol_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    symbol_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    symbol_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    symbol_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    symbol_starts_with?: InputMaybe<Scalars['String']['input']>;
+    symbol_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    whitelistedVaults_?: InputMaybe<WhitelistedToken_Filter>;
+};
+declare enum TokenInformation_OrderBy {
+    ActiveIncentives = "activeIncentives",
+    Address = "address",
+    Decimals = "decimals",
+    DistributedIncentives = "distributedIncentives",
+    DistributedIncentivesByVault = "distributedIncentivesByVault",
+    Id = "id",
+    Name = "name",
+    ReceivedValidators = "receivedValidators",
+    StakedVaults = "stakedVaults",
+    Symbol = "symbol",
+    WhitelistedVaults = "whitelistedVaults"
+}
+/**
+ * Data for the amount of BGT boosted to a Validator by a User (User -> Validator)
+ * `dropQueue` is the amount of BGT that will be removed from the Validator after activation
+ * `queued` is the amount of BGT that will be added to the Validator after activation
+ *
+ */
+type UserBoost = {
+    __typename?: 'UserBoost';
+    activeBoostAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Bytes']['output'];
+    queuedBoostAmount: Scalars['BigDecimal']['output'];
+    queuedBoostStartBlock?: Maybe<Scalars['BigInt']['output']>;
+    queuedBoostStartTimestamp?: Maybe<Scalars['BigInt']['output']>;
+    queuedDropBoostAmount: Scalars['BigDecimal']['output'];
+    queuedDropBoostStartBlock?: Maybe<Scalars['BigInt']['output']>;
+    queuedDropBoostStartTimestamp?: Maybe<Scalars['BigInt']['output']>;
+    updatedAtBlock: Scalars['BigInt']['output'];
+    updatedAtTimestamp: Scalars['BigInt']['output'];
+    user: Scalars['Bytes']['output'];
+    validator: Validator;
+};
+type UserBoost_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    activeBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    activeBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    and?: InputMaybe<Array<InputMaybe<UserBoost_Filter>>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<UserBoost_Filter>>>;
+    queuedBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedBoostStartBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedBoostStartBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedBoostStartTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedBoostStartTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedBoostStartTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedDropBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedDropBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedDropBoostStartBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedDropBoostStartBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedDropBoostStartTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedDropBoostStartTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedDropBoostStartTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    user?: InputMaybe<Scalars['Bytes']['input']>;
+    user_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    user_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum UserBoost_OrderBy {
+    ActiveBoostAmount = "activeBoostAmount",
+    Id = "id",
+    QueuedBoostAmount = "queuedBoostAmount",
+    QueuedBoostStartBlock = "queuedBoostStartBlock",
+    QueuedBoostStartTimestamp = "queuedBoostStartTimestamp",
+    QueuedDropBoostAmount = "queuedDropBoostAmount",
+    QueuedDropBoostStartBlock = "queuedDropBoostStartBlock",
+    QueuedDropBoostStartTimestamp = "queuedDropBoostStartTimestamp",
+    UpdatedAtBlock = "updatedAtBlock",
+    UpdatedAtTimestamp = "updatedAtTimestamp",
+    User = "user",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+/**
+ * Fees collected by the User via the BGTStaker contract
+ *
+ */
+type UserFeeHistory = {
+    __typename?: 'UserFeeHistory';
+    blockNumber: Scalars['BigInt']['output'];
+    collectedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Bytes']['output'];
+    timestamp: Scalars['BigInt']['output'];
+    txHash: Scalars['Bytes']['output'];
+    user: Scalars['Bytes']['output'];
+};
+type UserFeeHistory_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<UserFeeHistory_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    collectedBGTAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    collectedBGTAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    collectedBGTAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    collectedBGTAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    collectedBGTAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    collectedBGTAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    collectedBGTAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    collectedBGTAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<UserFeeHistory_Filter>>>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    user?: InputMaybe<Scalars['Bytes']['input']>;
+    user_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    user_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+};
+declare enum UserFeeHistory_OrderBy {
+    BlockNumber = "blockNumber",
+    CollectedBgtAmount = "collectedBGTAmount",
+    Id = "id",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    User = "user"
+}
+/**
+ * Amount of token staked to a Vault by a User (User -> Vault)
+ *
+ */
+type UserVaultStake = {
+    __typename?: 'UserVaultStake';
+    amount: Scalars['BigDecimal']['output'];
+    id: Scalars['Bytes']['output'];
+    updatedAtBlock: Scalars['BigInt']['output'];
+    updatedAtTimestamp: Scalars['BigInt']['output'];
+    user: Scalars['Bytes']['output'];
+    vault: Vault;
+};
+type UserVaultStake_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    amount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    amount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    amount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    amount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    amount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    amount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    amount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    amount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    and?: InputMaybe<Array<InputMaybe<UserVaultStake_Filter>>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<UserVaultStake_Filter>>>;
+    updatedAtBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    updatedAtTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    updatedAtTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    user?: InputMaybe<Scalars['Bytes']['input']>;
+    user_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    user_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    user_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    user_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+    vault_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_gt?: InputMaybe<Scalars['String']['input']>;
+    vault_gte?: InputMaybe<Scalars['String']['input']>;
+    vault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_lt?: InputMaybe<Scalars['String']['input']>;
+    vault_lte?: InputMaybe<Scalars['String']['input']>;
+    vault_not?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum UserVaultStake_OrderBy {
+    Amount = "amount",
+    Id = "id",
+    UpdatedAtBlock = "updatedAtBlock",
+    UpdatedAtTimestamp = "updatedAtTimestamp",
+    User = "user",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type Validator = {
+    __typename?: 'Validator';
+    activeBoostAmount: Scalars['BigDecimal']['output'];
+    blockRewards?: Maybe<Array<BlockReward>>;
+    boostHistory?: Maybe<Array<Boost>>;
+    boostStats?: Maybe<Array<BoostByValidator>>;
+    commissionRate: Scalars['BigInt']['output'];
+    distributedIncentives?: Maybe<Array<IncentiveDistribution>>;
+    id: Scalars['Bytes']['output'];
+    maxWeightPerVaultUpdatedCheckedAtBlock: Scalars['BigInt']['output'];
+    operator: Scalars['Bytes']['output'];
+    publicKey: Scalars['Bytes']['output'];
+    queuedBoostAmount: Scalars['BigDecimal']['output'];
+    queuedCommissionRate: Scalars['BigInt']['output'];
+    queuedCommissionRateStartBlock: Scalars['BigInt']['output'];
+    queuedCommissionRateStartTimestamp: Scalars['BigInt']['output'];
+    queuedDropBoostAmount: Scalars['BigDecimal']['output'];
+    queuedRewardAllocation?: Maybe<RewardAllocationQueue>;
+    receivedIncentiveTokens?: Maybe<Array<IncentiveTokensByValidator>>;
+    rewardAllocationActivation: RewardAllocationActivation;
+    rewardAllocationActivationHistory?: Maybe<Array<RewardAllocationActivation>>;
+    rewardAllocationQueueHistory?: Maybe<Array<RewardAllocationQueue>>;
+    rewardAllocator?: Maybe<Scalars['Bytes']['output']>;
+    uniqueTokensRewardedCount: Scalars['BigInt']['output'];
+    userBoosts?: Maybe<Array<UserBoost>>;
+    usersActiveBoostCount: Scalars['BigInt']['output'];
+    usersQueuedBoostCount: Scalars['BigInt']['output'];
+    usersQueuedDropBoostCount: Scalars['BigInt']['output'];
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorBlockRewardsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<BlockReward_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<BlockReward_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorBoostHistoryArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Boost_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<Boost_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorBoostStatsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<BoostByValidator_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorDistributedIncentivesArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IncentiveDistribution_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorReceivedIncentiveTokensArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveTokensByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IncentiveTokensByValidator_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorRewardAllocationActivationHistoryArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationActivation_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<RewardAllocationActivation_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorRewardAllocationQueueHistoryArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationQueue_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<RewardAllocationQueue_Filter>;
+};
+/**
+ * Validators distribute BGT rewards to Vaults
+ * Validators receive Incentive Tokens (Incentives) from Vaults
+ *
+ */
+type ValidatorUserBoostsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserBoost_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<UserBoost_Filter>;
+};
+/**
+ * Historical Validator commission changes
+ *
+ */
+type ValidatorCommissionHistory = {
+    __typename?: 'ValidatorCommissionHistory';
+    blockNumber: Scalars['BigInt']['output'];
+    id: Scalars['Bytes']['output'];
+    newRate: Scalars['BigInt']['output'];
+    oldRate: Scalars['BigInt']['output'];
+    timestamp: Scalars['BigInt']['output'];
+    txHash: Scalars['Bytes']['output'];
+    validator: Validator;
+};
+type ValidatorCommissionHistory_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<ValidatorCommissionHistory_Filter>>>;
+    blockNumber?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    blockNumber_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not?: InputMaybe<Scalars['BigInt']['input']>;
+    blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    newRate?: InputMaybe<Scalars['BigInt']['input']>;
+    newRate_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    newRate_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    newRate_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    newRate_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    newRate_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    newRate_not?: InputMaybe<Scalars['BigInt']['input']>;
+    newRate_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    oldRate?: InputMaybe<Scalars['BigInt']['input']>;
+    oldRate_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    oldRate_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    oldRate_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    oldRate_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    oldRate_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    oldRate_not?: InputMaybe<Scalars['BigInt']['input']>;
+    oldRate_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<ValidatorCommissionHistory_Filter>>>;
+    timestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    timestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    txHash?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    txHash_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    txHash_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    validator?: InputMaybe<Scalars['String']['input']>;
+    validator_?: InputMaybe<Validator_Filter>;
+    validator_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_gt?: InputMaybe<Scalars['String']['input']>;
+    validator_gte?: InputMaybe<Scalars['String']['input']>;
+    validator_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_lt?: InputMaybe<Scalars['String']['input']>;
+    validator_lte?: InputMaybe<Scalars['String']['input']>;
+    validator_not?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains?: InputMaybe<Scalars['String']['input']>;
+    validator_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    validator_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with?: InputMaybe<Scalars['String']['input']>;
+    validator_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum ValidatorCommissionHistory_OrderBy {
+    BlockNumber = "blockNumber",
+    Id = "id",
+    NewRate = "newRate",
+    OldRate = "oldRate",
+    Timestamp = "timestamp",
+    TxHash = "txHash",
+    Validator = "validator",
+    ValidatorActiveBoostAmount = "validator__activeBoostAmount",
+    ValidatorCommissionRate = "validator__commissionRate",
+    ValidatorId = "validator__id",
+    ValidatorMaxWeightPerVaultUpdatedCheckedAtBlock = "validator__maxWeightPerVaultUpdatedCheckedAtBlock",
+    ValidatorOperator = "validator__operator",
+    ValidatorPublicKey = "validator__publicKey",
+    ValidatorQueuedBoostAmount = "validator__queuedBoostAmount",
+    ValidatorQueuedCommissionRate = "validator__queuedCommissionRate",
+    ValidatorQueuedCommissionRateStartBlock = "validator__queuedCommissionRateStartBlock",
+    ValidatorQueuedCommissionRateStartTimestamp = "validator__queuedCommissionRateStartTimestamp",
+    ValidatorQueuedDropBoostAmount = "validator__queuedDropBoostAmount",
+    ValidatorRewardAllocator = "validator__rewardAllocator",
+    ValidatorUniqueTokensRewardedCount = "validator__uniqueTokensRewardedCount",
+    ValidatorUsersActiveBoostCount = "validator__usersActiveBoostCount",
+    ValidatorUsersQueuedBoostCount = "validator__usersQueuedBoostCount",
+    ValidatorUsersQueuedDropBoostCount = "validator__usersQueuedDropBoostCount"
+}
+type Validator_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    activeBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    activeBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    activeBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    and?: InputMaybe<Array<InputMaybe<Validator_Filter>>>;
+    blockRewards_?: InputMaybe<BlockReward_Filter>;
+    boostHistory_?: InputMaybe<Boost_Filter>;
+    boostStats_?: InputMaybe<BoostByValidator_Filter>;
+    commissionRate?: InputMaybe<Scalars['BigInt']['input']>;
+    commissionRate_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    commissionRate_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    commissionRate_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    commissionRate_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    commissionRate_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    commissionRate_not?: InputMaybe<Scalars['BigInt']['input']>;
+    commissionRate_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    distributedIncentives_?: InputMaybe<IncentiveDistribution_Filter>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    maxWeightPerVaultUpdatedCheckedAtBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    maxWeightPerVaultUpdatedCheckedAtBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    operator?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    operator_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_not?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    operator_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<Validator_Filter>>>;
+    publicKey?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    publicKey_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_not?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    publicKey_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    queuedBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedCommissionRate?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedCommissionRateStartBlock_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartBlock_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedCommissionRateStartTimestamp?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartTimestamp_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartTimestamp_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartTimestamp_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedCommissionRateStartTimestamp_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartTimestamp_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartTimestamp_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRateStartTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedCommissionRate_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRate_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRate_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedCommissionRate_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRate_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRate_not?: InputMaybe<Scalars['BigInt']['input']>;
+    queuedCommissionRate_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    queuedDropBoostAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedDropBoostAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    queuedDropBoostAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    queuedRewardAllocation?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_?: InputMaybe<RewardAllocationQueue_Filter>;
+    queuedRewardAllocation_contains?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_ends_with?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_gt?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_gte?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    queuedRewardAllocation_lt?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_lte?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not_contains?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    queuedRewardAllocation_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_starts_with?: InputMaybe<Scalars['String']['input']>;
+    queuedRewardAllocation_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    receivedIncentiveTokens_?: InputMaybe<IncentiveTokensByValidator_Filter>;
+    rewardAllocationActivation?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivationHistory_?: InputMaybe<RewardAllocationActivation_Filter>;
+    rewardAllocationActivation_?: InputMaybe<RewardAllocationActivation_Filter>;
+    rewardAllocationActivation_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_gt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_gte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocationActivation_lt?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_lte?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not_contains?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rewardAllocationActivation_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationActivation_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationQueueHistory_?: InputMaybe<RewardAllocationQueue_Filter>;
+    rewardAllocator?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    rewardAllocator_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_not?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    rewardAllocator_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    uniqueTokensRewardedCount?: InputMaybe<Scalars['BigInt']['input']>;
+    uniqueTokensRewardedCount_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    uniqueTokensRewardedCount_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    uniqueTokensRewardedCount_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    uniqueTokensRewardedCount_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    uniqueTokensRewardedCount_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    uniqueTokensRewardedCount_not?: InputMaybe<Scalars['BigInt']['input']>;
+    uniqueTokensRewardedCount_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    userBoosts_?: InputMaybe<UserBoost_Filter>;
+    usersActiveBoostCount?: InputMaybe<Scalars['BigInt']['input']>;
+    usersActiveBoostCount_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    usersActiveBoostCount_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    usersActiveBoostCount_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    usersActiveBoostCount_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    usersActiveBoostCount_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    usersActiveBoostCount_not?: InputMaybe<Scalars['BigInt']['input']>;
+    usersActiveBoostCount_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    usersQueuedBoostCount?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedBoostCount_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedBoostCount_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedBoostCount_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    usersQueuedBoostCount_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedBoostCount_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedBoostCount_not?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedBoostCount_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    usersQueuedDropBoostCount?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedDropBoostCount_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedDropBoostCount_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedDropBoostCount_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    usersQueuedDropBoostCount_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedDropBoostCount_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedDropBoostCount_not?: InputMaybe<Scalars['BigInt']['input']>;
+    usersQueuedDropBoostCount_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+};
+declare enum Validator_OrderBy {
+    ActiveBoostAmount = "activeBoostAmount",
+    BlockRewards = "blockRewards",
+    BoostHistory = "boostHistory",
+    BoostStats = "boostStats",
+    CommissionRate = "commissionRate",
+    DistributedIncentives = "distributedIncentives",
+    Id = "id",
+    MaxWeightPerVaultUpdatedCheckedAtBlock = "maxWeightPerVaultUpdatedCheckedAtBlock",
+    Operator = "operator",
+    PublicKey = "publicKey",
+    QueuedBoostAmount = "queuedBoostAmount",
+    QueuedCommissionRate = "queuedCommissionRate",
+    QueuedCommissionRateStartBlock = "queuedCommissionRateStartBlock",
+    QueuedCommissionRateStartTimestamp = "queuedCommissionRateStartTimestamp",
+    QueuedDropBoostAmount = "queuedDropBoostAmount",
+    QueuedRewardAllocation = "queuedRewardAllocation",
+    QueuedRewardAllocationBlockNumber = "queuedRewardAllocation__blockNumber",
+    QueuedRewardAllocationId = "queuedRewardAllocation__id",
+    QueuedRewardAllocationTimestamp = "queuedRewardAllocation__timestamp",
+    QueuedRewardAllocationTxHash = "queuedRewardAllocation__txHash",
+    ReceivedIncentiveTokens = "receivedIncentiveTokens",
+    RewardAllocationActivation = "rewardAllocationActivation",
+    RewardAllocationActivationHistory = "rewardAllocationActivationHistory",
+    RewardAllocationActivationBlockNumber = "rewardAllocationActivation__blockNumber",
+    RewardAllocationActivationId = "rewardAllocationActivation__id",
+    RewardAllocationActivationTimestamp = "rewardAllocationActivation__timestamp",
+    RewardAllocationActivationTxHash = "rewardAllocationActivation__txHash",
+    RewardAllocationQueueHistory = "rewardAllocationQueueHistory",
+    RewardAllocator = "rewardAllocator",
+    UniqueTokensRewardedCount = "uniqueTokensRewardedCount",
+    UserBoosts = "userBoosts",
+    UsersActiveBoostCount = "usersActiveBoostCount",
+    UsersQueuedBoostCount = "usersQueuedBoostCount",
+    UsersQueuedDropBoostCount = "usersQueuedDropBoostCount"
+}
+/**
+ * Vaults are given BGT rewards by Validators
+ * Vaults distribute Incentive Tokens (Incentives) to Validators
+ *
+ */
+type Vault = {
+    __typename?: 'Vault';
+    activeIncentives?: Maybe<Array<ActiveIncentive>>;
+    address: Scalars['Bytes']['output'];
+    distributedIncentives?: Maybe<Array<IncentiveDistribution>>;
+    id: Scalars['Bytes']['output'];
+    isWhitelisted: Scalars['Boolean']['output'];
+    rawMetadata?: Maybe<Scalars['String']['output']>;
+    rewardAllocationWeights?: Maybe<Array<RewardAllocationWeight>>;
+    stakedUsers?: Maybe<Array<UserVaultStake>>;
+    stakingToken: TokenInformation;
+    stakingTokenAmount: Scalars['BigDecimal']['output'];
+    unscaledStakingTokenAmount: Scalars['BigInt']['output'];
+    whitelistedTokens?: Maybe<Array<WhitelistedToken>>;
+};
+/**
+ * Vaults are given BGT rewards by Validators
+ * Vaults distribute Incentive Tokens (Incentives) to Validators
+ *
+ */
+type VaultActiveIncentivesArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<ActiveIncentive_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<ActiveIncentive_Filter>;
+};
+/**
+ * Vaults are given BGT rewards by Validators
+ * Vaults distribute Incentive Tokens (Incentives) to Validators
+ *
+ */
+type VaultDistributedIncentivesArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<IncentiveDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<IncentiveDistribution_Filter>;
+};
+/**
+ * Vaults are given BGT rewards by Validators
+ * Vaults distribute Incentive Tokens (Incentives) to Validators
+ *
+ */
+type VaultRewardAllocationWeightsArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<RewardAllocationWeight_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<RewardAllocationWeight_Filter>;
+};
+/**
+ * Vaults are given BGT rewards by Validators
+ * Vaults distribute Incentive Tokens (Incentives) to Validators
+ *
+ */
+type VaultStakedUsersArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<UserVaultStake_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<UserVaultStake_Filter>;
+};
+/**
+ * Vaults are given BGT rewards by Validators
+ * Vaults distribute Incentive Tokens (Incentives) to Validators
+ *
+ */
+type VaultWhitelistedTokensArgs = {
+    first?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<WhitelistedToken_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    where?: InputMaybe<WhitelistedToken_Filter>;
+};
+type Vault_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    activeIncentives_?: InputMaybe<ActiveIncentive_Filter>;
+    address?: InputMaybe<Scalars['Bytes']['input']>;
+    address_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    address_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    address_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    address_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    address_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    address_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    address_not?: InputMaybe<Scalars['Bytes']['input']>;
+    address_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    address_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    and?: InputMaybe<Array<InputMaybe<Vault_Filter>>>;
+    distributedIncentives_?: InputMaybe<IncentiveDistribution_Filter>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    isWhitelisted?: InputMaybe<Scalars['Boolean']['input']>;
+    isWhitelisted_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    isWhitelisted_not?: InputMaybe<Scalars['Boolean']['input']>;
+    isWhitelisted_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<Vault_Filter>>>;
+    rawMetadata?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_contains?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_gt?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_gte?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rawMetadata_lt?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_lte?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not_contains?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    rawMetadata_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_starts_with?: InputMaybe<Scalars['String']['input']>;
+    rawMetadata_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    rewardAllocationWeights_?: InputMaybe<RewardAllocationWeight_Filter>;
+    stakedUsers_?: InputMaybe<UserVaultStake_Filter>;
+    stakingToken?: InputMaybe<Scalars['String']['input']>;
+    stakingTokenAmount?: InputMaybe<Scalars['BigDecimal']['input']>;
+    stakingTokenAmount_gt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    stakingTokenAmount_gte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    stakingTokenAmount_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    stakingTokenAmount_lt?: InputMaybe<Scalars['BigDecimal']['input']>;
+    stakingTokenAmount_lte?: InputMaybe<Scalars['BigDecimal']['input']>;
+    stakingTokenAmount_not?: InputMaybe<Scalars['BigDecimal']['input']>;
+    stakingTokenAmount_not_in?: InputMaybe<Array<Scalars['BigDecimal']['input']>>;
+    stakingToken_?: InputMaybe<TokenInformation_Filter>;
+    stakingToken_contains?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_ends_with?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_gt?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_gte?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    stakingToken_lt?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_lte?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not_contains?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    stakingToken_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_starts_with?: InputMaybe<Scalars['String']['input']>;
+    stakingToken_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    unscaledStakingTokenAmount?: InputMaybe<Scalars['BigInt']['input']>;
+    unscaledStakingTokenAmount_gt?: InputMaybe<Scalars['BigInt']['input']>;
+    unscaledStakingTokenAmount_gte?: InputMaybe<Scalars['BigInt']['input']>;
+    unscaledStakingTokenAmount_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    unscaledStakingTokenAmount_lt?: InputMaybe<Scalars['BigInt']['input']>;
+    unscaledStakingTokenAmount_lte?: InputMaybe<Scalars['BigInt']['input']>;
+    unscaledStakingTokenAmount_not?: InputMaybe<Scalars['BigInt']['input']>;
+    unscaledStakingTokenAmount_not_in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
+    whitelistedTokens_?: InputMaybe<WhitelistedToken_Filter>;
+};
+declare enum Vault_OrderBy {
+    ActiveIncentives = "activeIncentives",
+    Address = "address",
+    DistributedIncentives = "distributedIncentives",
+    Id = "id",
+    IsWhitelisted = "isWhitelisted",
+    RawMetadata = "rawMetadata",
+    RewardAllocationWeights = "rewardAllocationWeights",
+    StakedUsers = "stakedUsers",
+    StakingToken = "stakingToken",
+    StakingTokenAmount = "stakingTokenAmount",
+    StakingTokenAddress = "stakingToken__address",
+    StakingTokenDecimals = "stakingToken__decimals",
+    StakingTokenId = "stakingToken__id",
+    StakingTokenName = "stakingToken__name",
+    StakingTokenSymbol = "stakingToken__symbol",
+    UnscaledStakingTokenAmount = "unscaledStakingTokenAmount",
+    WhitelistedTokens = "whitelistedTokens"
+}
+type WhitelistedToken = {
+    __typename?: 'WhitelistedToken';
+    id: Scalars['Bytes']['output'];
+    manager: Scalars['Bytes']['output'];
+    token: TokenInformation;
+    vault: Vault;
+};
+type WhitelistedToken_Filter = {
+    /** Filter for the block changed event. */
+    _change_block?: InputMaybe<BlockChangedFilter>;
+    and?: InputMaybe<Array<InputMaybe<WhitelistedToken_Filter>>>;
+    id?: InputMaybe<Scalars['Bytes']['input']>;
+    id_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    id_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    id_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    id_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    manager?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_gt?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_gte?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    manager_lt?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_lte?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_not?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_not_contains?: InputMaybe<Scalars['Bytes']['input']>;
+    manager_not_in?: InputMaybe<Array<Scalars['Bytes']['input']>>;
+    or?: InputMaybe<Array<InputMaybe<WhitelistedToken_Filter>>>;
+    token?: InputMaybe<Scalars['String']['input']>;
+    token_?: InputMaybe<TokenInformation_Filter>;
+    token_contains?: InputMaybe<Scalars['String']['input']>;
+    token_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_gt?: InputMaybe<Scalars['String']['input']>;
+    token_gte?: InputMaybe<Scalars['String']['input']>;
+    token_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_lt?: InputMaybe<Scalars['String']['input']>;
+    token_lte?: InputMaybe<Scalars['String']['input']>;
+    token_not?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains?: InputMaybe<Scalars['String']['input']>;
+    token_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    token_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with?: InputMaybe<Scalars['String']['input']>;
+    token_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault?: InputMaybe<Scalars['String']['input']>;
+    vault_?: InputMaybe<Vault_Filter>;
+    vault_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_gt?: InputMaybe<Scalars['String']['input']>;
+    vault_gte?: InputMaybe<Scalars['String']['input']>;
+    vault_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_lt?: InputMaybe<Scalars['String']['input']>;
+    vault_lte?: InputMaybe<Scalars['String']['input']>;
+    vault_not?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains?: InputMaybe<Scalars['String']['input']>;
+    vault_not_contains_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_ends_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
+    vault_not_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_not_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with?: InputMaybe<Scalars['String']['input']>;
+    vault_starts_with_nocase?: InputMaybe<Scalars['String']['input']>;
+};
+declare enum WhitelistedToken_OrderBy {
+    Id = "id",
+    Manager = "manager",
+    Token = "token",
+    TokenAddress = "token__address",
+    TokenDecimals = "token__decimals",
+    TokenId = "token__id",
+    TokenName = "token__name",
+    TokenSymbol = "token__symbol",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+type _Block_ = {
+    __typename?: '_Block_';
+    /** The hash of the block */
+    hash?: Maybe<Scalars['Bytes']['output']>;
+    /** The block number */
+    number: Scalars['Int']['output'];
+    /** The hash of the parent block */
+    parentHash?: Maybe<Scalars['Bytes']['output']>;
+    /** Integer representation of the timestamp stored in blocks for the chain */
+    timestamp?: Maybe<Scalars['Int']['output']>;
+};
+/** The type for the top-level _meta field */
+type _Meta_ = {
+    __typename?: '_Meta_';
+    /**
+     * Information about a specific subgraph block. The hash of the block
+     * will be null if the _meta field has a block constraint that asks for
+     * a block number. It will be filled if the _meta field has no block constraint
+     * and therefore asks for the latest  block
+     *
+     */
+    block: _Block_;
+    /** The deployment ID */
+    deployment: Scalars['String']['output'];
+    /** If `true`, the subgraph encountered indexing errors at some past block */
+    hasIndexingErrors: Scalars['Boolean']['output'];
+};
+declare enum _SubgraphErrorPolicy_ {
+    /** Data will be returned even if the subgraph has indexing errors */
+    Allow = "allow",
+    /** If the subgraph has indexing errors, data will be omitted. The default. */
+    Deny = "deny"
+}
+type ValidatorMinimalFragment = {
+    __typename?: 'Validator';
+    id: any;
+    publicKey: any;
+    activeBoostAmount: any;
+};
+type SubgraphStatusMetaFragment = {
+    __typename?: '_Meta_';
+    hasIndexingErrors: boolean;
+    block: {
+        __typename?: '_Block_';
+        timestamp?: number | null;
+    };
+};
+type GetUserValidatorInformationQueryVariables = Exact<{
+    address: Scalars['Bytes']['input'];
+    block?: InputMaybe<Block_Height>;
+}>;
+type GetUserValidatorInformationQuery = {
+    __typename?: 'Query';
+    userValidatorInformations: Array<{
+        __typename?: 'UserBoost';
+        id: any;
+        queuedBoostAmount: any;
+        activeBoostAmount: any;
+        queuedDropBoostAmount: any;
+        queuedDropBoostStartBlock?: any | null;
+        queuedBoostStartBlock?: any | null;
+        user: any;
+        validator: {
+            __typename?: 'Validator';
+            id: any;
+            publicKey: any;
+            activeBoostAmount: any;
+        };
+    }>;
+    _meta?: {
+        __typename?: '_Meta_';
+        hasIndexingErrors: boolean;
+        block: {
+            __typename?: '_Block_';
+            timestamp?: number | null;
+        };
+    } | null;
+};
+type GetValidValidatorQueryVariables = Exact<{
+    address: Scalars['ID']['input'];
+}>;
+type GetValidValidatorQuery = {
+    __typename?: 'Query';
+    validator?: {
+        __typename?: 'Validator';
+        id: any;
+        publicKey: any;
+        activeBoostAmount: any;
+    } | null;
+};
+type GetAllValidatorsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+type GetAllValidatorsQuery = {
+    __typename?: 'Query';
+    validators: Array<{
+        __typename?: 'Validator';
+        id: any;
+        publicKey: any;
+        activeBoostAmount: any;
+    }>;
+};
+type BoostByValidatorFragment = {
+    __typename?: 'BoostByValidator';
+    allTimeNetAmount: any;
+    netAmount: any;
+    id: any;
+    timestamp: any;
+};
+type BlockRewardStatsByValidatorFragment = {
+    __typename?: 'BlockRewardStatsByValidator';
+    timestamp: any;
+    distributedBGTAmount: any;
+    earnedBGTAmount: any;
+    validator: {
+        __typename?: 'Validator';
+        id: any;
+        publicKey: any;
+        activeBoostAmount: any;
+    };
+};
+type GetValidatorBlockStatsQueryVariables = Exact<{
+    pubKey?: InputMaybe<Scalars['Bytes']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+}>;
+type GetValidatorBlockStatsQuery = {
+    __typename?: 'Query';
+    blockStatsByValidators: Array<{
+        __typename?: 'BlockStatsByValidator';
+        blockCount: any;
+        allTimeBlockCount: any;
+        timestamp: any;
+        validator: {
+            __typename?: 'Validator';
+            id: any;
+            publicKey: any;
+            activeBoostAmount: any;
+        };
+    }>;
+    blockStats_collection: Array<{
+        __typename?: 'BlockStats';
+        blockCount: any;
+    }>;
+};
+type StakingTokenFragment = {
+    __typename?: 'TokenInformation';
+    address: string;
+    decimals: number;
+    name: string;
+    symbol: string;
+};
+type VaultMinimalFragment = {
+    __typename?: 'Vault';
+    id: any;
+    stakingTokenAmount: any;
+    address: any;
+};
+type VaultWithStakingTokenFragment = {
+    __typename?: 'Vault';
+    id: any;
+    stakingTokenAmount: any;
+    address: any;
+    stakingToken: {
+        __typename?: 'TokenInformation';
+        address: string;
+        decimals: number;
+        name: string;
+        symbol: string;
+    };
+};
+type GlobalInfoFragment = {
+    __typename?: 'GlobalInfo';
+    id: any;
+    rewardRate: any;
+    baseRewardRate: any;
+};
+type GetGaugesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+type GetGaugesQuery = {
+    __typename?: 'Query';
+    vaults: Array<{
+        __typename?: 'Vault';
+        id: any;
+        stakingTokenAmount: any;
+        address: any;
+        stakingToken: {
+            __typename?: 'TokenInformation';
+            address: string;
+            decimals: number;
+            name: string;
+            symbol: string;
+        };
+    }>;
+};
+type GetWeeklyBgtInflationQueryVariables = Exact<{
+    wbera: Scalars['ID']['input'];
+}>;
+type GetWeeklyBgtInflationQuery = {
+    __typename?: 'Query';
+    globalRewardDistributions: Array<{
+        __typename?: 'GlobalRewardDistribution';
+        distributedBGTAmount: any;
+    }>;
+    tokenInformation?: {
+        __typename?: 'TokenInformation';
+        address: string;
+        decimals: number;
+        name: string;
+        symbol: string;
+    } | null;
+};
+type GetRewardVaultQueryVariables = Exact<{
+    stakingToken?: InputMaybe<Scalars['String']['input']>;
+}>;
+type GetRewardVaultQuery = {
+    __typename?: 'Query';
+    vaults: Array<{
+        __typename?: 'Vault';
+        id: any;
+        stakingTokenAmount: any;
+        address: any;
+        stakingToken: {
+            __typename?: 'TokenInformation';
+            address: string;
+            decimals: number;
+            name: string;
+            symbol: string;
+        };
+    }>;
+};
+type GetValidatorByOperatorQueryVariables = Exact<{
+    operator: Scalars['Bytes']['input'];
+}>;
+type GetValidatorByOperatorQuery = {
+    __typename?: 'Query';
+    validators: Array<{
+        __typename?: 'Validator';
+        id: any;
+        publicKey: any;
+        activeBoostAmount: any;
+    }>;
+};
+type GetValidatorByAccountQueryVariables = Exact<{
+    account: Scalars['Bytes']['input'];
+}>;
+type GetValidatorByAccountQuery = {
+    __typename?: 'Query';
+    validators: Array<{
+        __typename?: 'Validator';
+        id: any;
+        publicKey: any;
+        activeBoostAmount: any;
+    }>;
+};
+type GetValidatorAnalyticsQueryVariables = Exact<{
+    pubKey: Scalars['Bytes']['input'];
+    timestamp: Scalars['Timestamp']['input'];
+}>;
+type GetValidatorAnalyticsQuery = {
+    __typename?: 'Query';
+    boostByValidators: Array<{
+        __typename?: 'BoostByValidator';
+        allTimeNetAmount: any;
+        netAmount: any;
+        id: any;
+        timestamp: any;
+    }>;
+    blockRewardStatsByValidators: Array<{
+        __typename?: 'BlockRewardStatsByValidator';
+        timestamp: any;
+        distributedBGTAmount: any;
+        earnedBGTAmount: any;
+        validator: {
+            __typename?: 'Validator';
+            id: any;
+            publicKey: any;
+            activeBoostAmount: any;
+        };
+    }>;
+    incentiveDistributionByValidators: Array<{
+        __typename?: 'IncentiveDistributionByValidator';
+        receivedTokenAmount: any;
+        timestamp: any;
+        id: any;
+        token: {
+            __typename?: 'TokenInformation';
+            address: string;
+            decimals: number;
+            name: string;
+            symbol: string;
+        };
+    }>;
+    userValidatorBoostQueued: Array<{
+        __typename?: 'UserBoost';
+        queuedBoostAmount: any;
+        user: any;
+    }>;
+    userValidatorBoostDeposited: Array<{
+        __typename?: 'UserBoost';
+        activeBoostAmount: any;
+        user: any;
+    }>;
+};
+type GetIncentiveFeeClaimStatsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+type GetIncentiveFeeClaimStatsQuery = {
+    __typename?: 'Query';
+    incentiveFeeClaims: Array<{
+        __typename?: 'IncentiveFeeClaim';
+        recipient: any;
+        payoutAmount: any;
+        timestamp: any;
+    }>;
+};
+declare const SubgraphStatusMeta: _apollo_client.DocumentNode;
+/**
+ * Aggregation for the amount of BGT boosted to a Validator (User -> Validator)
+ *
+ */
+type BoostByValidator = {
+    __typename?: 'BoostByValidator';
+    allTimeBoostAmount: Scalars['BigDecimal']['output'];
+    allTimeDropBoostAmount: Scalars['BigDecimal']['output'];
+    allTimeNetAmount: Scalars['BigDecimal']['output'];
+    boostAmount: Scalars['BigDecimal']['output'];
+    dropBoostAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    netAmount: Scalars['BigDecimal']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    validator: Validator;
+};
+declare const BoostByValidator: _apollo_client.DocumentNode;
+declare const ValidatorMinimal: _apollo_client.DocumentNode;
+/**
+ * Aggregation for the amount of BGT awarded to a Validator for proposing a block by Validator (Distributor -> Validator)
+ *
+ */
+type BlockRewardStatsByValidator = {
+    __typename?: 'BlockRewardStatsByValidator';
+    allTimeDistributedBGTAmount: Scalars['BigDecimal']['output'];
+    allTimeEarnedBGTAmount: Scalars['BigDecimal']['output'];
+    distributedBGTAmount: Scalars['BigDecimal']['output'];
+    earnedBGTAmount: Scalars['BigDecimal']['output'];
+    id: Scalars['Int8']['output'];
+    timestamp: Scalars['Timestamp']['output'];
+    validator: Validator;
+};
+declare const BlockRewardStatsByValidator: _apollo_client.DocumentNode;
+declare const VaultMinimal: _apollo_client.DocumentNode;
+declare const StakingToken: _apollo_client.DocumentNode;
+declare const VaultWithStakingToken: _apollo_client.DocumentNode;
+/**
+ * Global stats for Proof of Liquidity
+ *
+ */
+type GlobalInfo = {
+    __typename?: 'GlobalInfo';
+    baseRewardRate: Scalars['BigDecimal']['output'];
+    id: Scalars['Bytes']['output'];
+    maxNumWeightsPerRewardAllocation?: Maybe<Scalars['BigInt']['output']>;
+    minBoostedRewardRate: Scalars['BigDecimal']['output'];
+    rewardAllocationMaxWeightPerVault?: Maybe<RewardAllocationMaxWeightHistory>;
+    rewardRate: Scalars['BigDecimal']['output'];
+    totalActiveBoostAmount: Scalars['BigDecimal']['output'];
+    totalBGTRedeemedAmount: Scalars['BigDecimal']['output'];
+    totalDistributedAmount: Scalars['BigDecimal']['output'];
+    totalQueuedBoostAmount: Scalars['BigDecimal']['output'];
+    totalQueuedDropBoostAmount: Scalars['BigDecimal']['output'];
+    totalValidatorsCount: Scalars['BigInt']['output'];
+};
+declare const GlobalInfo: _apollo_client.DocumentNode;
+declare const GetUserValidatorInformation: _apollo_client.DocumentNode;
+declare const GetValidValidator: _apollo_client.DocumentNode;
+declare const GetAllValidators: _apollo_client.DocumentNode;
+declare const GetValidatorBlockStats: _apollo_client.DocumentNode;
+declare const GetGauges: _apollo_client.DocumentNode;
+declare const GetWeeklyBgtInflation: _apollo_client.DocumentNode;
+declare const GetRewardVault: _apollo_client.DocumentNode;
+declare const GetValidatorByOperator: _apollo_client.DocumentNode;
+declare const GetValidatorByAccount: _apollo_client.DocumentNode;
+declare const GetValidatorAnalytics: _apollo_client.DocumentNode;
+declare const GetIncentiveFeeClaimStats: _apollo_client.DocumentNode;
+interface PossibleTypesResultData {
+    possibleTypes: {
+        [key: string]: string[];
+    };
+}
+declare const result: PossibleTypesResultData;
+
+export { type ActiveIncentive, type ActiveIncentive_Filter, ActiveIncentive_OrderBy, Aggregation_Interval, type BlockChangedFilter, type BlockReward, type BlockRewardStats, BlockRewardStatsByValidator, type BlockRewardStatsByValidatorFragment, type BlockRewardStatsByValidator_Filter, type BlockRewardStats_Filter, type BlockReward_Filter, BlockReward_OrderBy, type BlockStats, type BlockStatsByValidator, type BlockStatsByValidator_Filter, type BlockStats_Filter, type Block_Height, type Boost, BoostByValidator, type BoostByValidatorFragment, type BoostByValidator_Filter, type Boost_Filter, Boost_OrderBy, type Exact, GetAllValidators, type GetAllValidatorsQuery, type GetAllValidatorsQueryVariables, GetGauges, type GetGaugesQuery, type GetGaugesQueryVariables, GetIncentiveFeeClaimStats, type GetIncentiveFeeClaimStatsQuery, type GetIncentiveFeeClaimStatsQueryVariables, GetRewardVault, type GetRewardVaultQuery, type GetRewardVaultQueryVariables, GetUserValidatorInformation, type GetUserValidatorInformationQuery, type GetUserValidatorInformationQueryVariables, GetValidValidator, type GetValidValidatorQuery, type GetValidValidatorQueryVariables, GetValidatorAnalytics, type GetValidatorAnalyticsQuery, type GetValidatorAnalyticsQueryVariables, GetValidatorBlockStats, type GetValidatorBlockStatsQuery, type GetValidatorBlockStatsQueryVariables, GetValidatorByAccount, type GetValidatorByAccountQuery, type GetValidatorByAccountQueryVariables, GetValidatorByOperator, type GetValidatorByOperatorQuery, type GetValidatorByOperatorQueryVariables, GetWeeklyBgtInflation, type GetWeeklyBgtInflationQuery, type GetWeeklyBgtInflationQueryVariables, GlobalInfo, type GlobalInfoFragment, type GlobalInfo_Filter, GlobalInfo_OrderBy, type GlobalRewardDistribution, type GlobalRewardDistribution_Filter, type IncentiveDistribution, type IncentiveDistributionByValidator, type IncentiveDistributionByValidator_Filter, type IncentiveDistributionByVault, type IncentiveDistributionByVault_Filter, type IncentiveDistribution_Filter, IncentiveDistribution_OrderBy, type IncentiveFeeClaim, type IncentiveFeeClaimStats, type IncentiveFeeClaimStats_Filter, type IncentiveFeeClaim_Filter, IncentiveFeeClaim_OrderBy, type IncentiveFeePayoutAmountHistory, type IncentiveFeePayoutAmountHistory_Filter, IncentiveFeePayoutAmountHistory_OrderBy, type IncentiveTokensByValidator, type IncentiveTokensByValidator_Filter, IncentiveTokensByValidator_OrderBy, type Incremental, type InputMaybe, type MakeEmpty, type MakeMaybe, type MakeOptional, type Maybe, OrderDirection, type PossibleTypesResultData, type Query, type QueryActiveIncentiveArgs, type QueryActiveIncentivesArgs, type QueryBlockRewardArgs, type QueryBlockRewardStatsByValidatorsArgs, type QueryBlockRewardStats_CollectionArgs, type QueryBlockRewardsArgs, type QueryBlockStatsByValidatorsArgs, type QueryBlockStats_CollectionArgs, type QueryBoostArgs, type QueryBoostByValidatorsArgs, type QueryBoostsArgs, type QueryGlobalInfoArgs, type QueryGlobalInfosArgs, type QueryGlobalRewardDistributionsArgs, type QueryIncentiveDistributionArgs, type QueryIncentiveDistributionByValidatorsArgs, type QueryIncentiveDistributionByVaultsArgs, type QueryIncentiveDistributionsArgs, type QueryIncentiveFeeClaimArgs, type QueryIncentiveFeeClaimStats_CollectionArgs, type QueryIncentiveFeeClaimsArgs, type QueryIncentiveFeePayoutAmountHistoriesArgs, type QueryIncentiveFeePayoutAmountHistoryArgs, type QueryIncentiveTokensByValidatorArgs, type QueryIncentiveTokensByValidatorsArgs, type QueryRewardAllocationActivationArgs, type QueryRewardAllocationActivationsArgs, type QueryRewardAllocationArgs, type QueryRewardAllocationMaxWeightHistoriesArgs, type QueryRewardAllocationMaxWeightHistoryArgs, type QueryRewardAllocationQueueArgs, type QueryRewardAllocationQueuesArgs, type QueryRewardAllocationWeightArgs, type QueryRewardAllocationWeightsArgs, type QueryRewardAllocationsArgs, type QueryRewardDistributionArgs, type QueryRewardDistributionByVaultsArgs, type QueryRewardDistributionsArgs, type QueryRewardsDistributionByValidatorsArgs, type QueryTokenInformationArgs, type QueryTokenInformationsArgs, type QueryUserBoostArgs, type QueryUserBoostsArgs, type QueryUserFeeHistoriesArgs, type QueryUserFeeHistoryArgs, type QueryUserVaultStakeArgs, type QueryUserVaultStakesArgs, type QueryValidatorArgs, type QueryValidatorCommissionHistoriesArgs, type QueryValidatorCommissionHistoryArgs, type QueryValidatorsArgs, type QueryVaultArgs, type QueryVaultsArgs, type QueryWhitelistedTokenArgs, type QueryWhitelistedTokensArgs, type Query_MetaArgs, type RewardAllocation, type RewardAllocationActivation, type RewardAllocationActivation_Filter, RewardAllocationActivation_OrderBy, type RewardAllocationActivationsArgs, type RewardAllocationMaxWeightHistory, type RewardAllocationMaxWeightHistory_Filter, RewardAllocationMaxWeightHistory_OrderBy, type RewardAllocationQueue, type RewardAllocationQueue_Filter, RewardAllocationQueue_OrderBy, type RewardAllocationQueuesArgs, type RewardAllocationWeight, type RewardAllocationWeight_Filter, RewardAllocationWeight_OrderBy, type RewardAllocationWeightsArgs, type RewardAllocation_Filter, RewardAllocation_OrderBy, type RewardDistribution, type RewardDistributionByVault, type RewardDistributionByVault_Filter, type RewardDistribution_Filter, RewardDistribution_OrderBy, type RewardsDistributionByValidator, type RewardsDistributionByValidator_Filter, type Scalars, StakingToken, type StakingTokenFragment, SubgraphStatusMeta, type SubgraphStatusMetaFragment, type Subscription, type SubscriptionActiveIncentiveArgs, type SubscriptionActiveIncentivesArgs, type SubscriptionBlockRewardArgs, type SubscriptionBlockRewardStatsByValidatorsArgs, type SubscriptionBlockRewardStats_CollectionArgs, type SubscriptionBlockRewardsArgs, type SubscriptionBlockStatsByValidatorsArgs, type SubscriptionBlockStats_CollectionArgs, type SubscriptionBoostArgs, type SubscriptionBoostByValidatorsArgs, type SubscriptionBoostsArgs, type SubscriptionGlobalInfoArgs, type SubscriptionGlobalInfosArgs, type SubscriptionGlobalRewardDistributionsArgs, type SubscriptionIncentiveDistributionArgs, type SubscriptionIncentiveDistributionByValidatorsArgs, type SubscriptionIncentiveDistributionByVaultsArgs, type SubscriptionIncentiveDistributionsArgs, type SubscriptionIncentiveFeeClaimArgs, type SubscriptionIncentiveFeeClaimStats_CollectionArgs, type SubscriptionIncentiveFeeClaimsArgs, type SubscriptionIncentiveFeePayoutAmountHistoriesArgs, type SubscriptionIncentiveFeePayoutAmountHistoryArgs, type SubscriptionIncentiveTokensByValidatorArgs, type SubscriptionIncentiveTokensByValidatorsArgs, type SubscriptionRewardAllocationActivationArgs, type SubscriptionRewardAllocationActivationsArgs, type SubscriptionRewardAllocationArgs, type SubscriptionRewardAllocationMaxWeightHistoriesArgs, type SubscriptionRewardAllocationMaxWeightHistoryArgs, type SubscriptionRewardAllocationQueueArgs, type SubscriptionRewardAllocationQueuesArgs, type SubscriptionRewardAllocationWeightArgs, type SubscriptionRewardAllocationWeightsArgs, type SubscriptionRewardAllocationsArgs, type SubscriptionRewardDistributionArgs, type SubscriptionRewardDistributionByVaultsArgs, type SubscriptionRewardDistributionsArgs, type SubscriptionRewardsDistributionByValidatorsArgs, type SubscriptionTokenInformationArgs, type SubscriptionTokenInformationsArgs, type SubscriptionUserBoostArgs, type SubscriptionUserBoostsArgs, type SubscriptionUserFeeHistoriesArgs, type SubscriptionUserFeeHistoryArgs, type SubscriptionUserVaultStakeArgs, type SubscriptionUserVaultStakesArgs, type SubscriptionValidatorArgs, type SubscriptionValidatorCommissionHistoriesArgs, type SubscriptionValidatorCommissionHistoryArgs, type SubscriptionValidatorsArgs, type SubscriptionVaultArgs, type SubscriptionVaultsArgs, type SubscriptionWhitelistedTokenArgs, type SubscriptionWhitelistedTokensArgs, type Subscription_MetaArgs, type TokenInformation, type TokenInformationActiveIncentivesArgs, type TokenInformationDistributedIncentivesArgs, type TokenInformationDistributedIncentivesByVaultArgs, type TokenInformationReceivedValidatorsArgs, type TokenInformationStakedVaultsArgs, type TokenInformationWhitelistedVaultsArgs, type TokenInformation_Filter, TokenInformation_OrderBy, type UserBoost, type UserBoost_Filter, UserBoost_OrderBy, type UserFeeHistory, type UserFeeHistory_Filter, UserFeeHistory_OrderBy, type UserVaultStake, type UserVaultStake_Filter, UserVaultStake_OrderBy, type Validator, type ValidatorBlockRewardsArgs, type ValidatorBoostHistoryArgs, type ValidatorBoostStatsArgs, type ValidatorCommissionHistory, type ValidatorCommissionHistory_Filter, ValidatorCommissionHistory_OrderBy, type ValidatorDistributedIncentivesArgs, ValidatorMinimal, type ValidatorMinimalFragment, type ValidatorReceivedIncentiveTokensArgs, type ValidatorRewardAllocationActivationHistoryArgs, type ValidatorRewardAllocationQueueHistoryArgs, type ValidatorUserBoostsArgs, type Validator_Filter, Validator_OrderBy, type Vault, type VaultActiveIncentivesArgs, type VaultDistributedIncentivesArgs, VaultMinimal, type VaultMinimalFragment, type VaultRewardAllocationWeightsArgs, type VaultStakedUsersArgs, type VaultWhitelistedTokensArgs, VaultWithStakingToken, type VaultWithStakingTokenFragment, type Vault_Filter, Vault_OrderBy, type WhitelistedToken, type WhitelistedToken_Filter, WhitelistedToken_OrderBy, type _Block_, type _Meta_, _SubgraphErrorPolicy_, result as default };