@berachain/graphql 0.4.16-beta.1 → 0.4.16-beta.3

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

@@ -0,0 +1,4133 @@
+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: string;
+        output: string;
+    };
+    BigInt: {
+        input: string;
+        output: string;
+    };
+    Bytes: {
+        input: `0x${string}`;
+        output: `0x${string}`;
+    };
+    Int8: {
+        input: string;
+        output: string;
+    };
+    Timestamp: {
+        input: string;
+        output: string;
+    };
+};
+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"
+}
+/** Indicates whether the current, partially filled bucket should be included in the response. Defaults to `exclude` */
+declare enum Aggregation_Current {
+    /** Exclude the current, partially filled bucket from the response */
+    Exclude = "exclude",
+    /** Include the current, partially filled bucket in the response */
+    Include = "include"
+}
+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>;
+};
+declare enum BlockRewardStatsByValidator_OrderBy {
+    AllTimeDistributedBgtAmount = "allTimeDistributedBGTAmount",
+    AllTimeEarnedBgtAmount = "allTimeEarnedBGTAmount",
+    DistributedBgtAmount = "distributedBGTAmount",
+    EarnedBgtAmount = "earnedBGTAmount",
+    Id = "id",
+    Timestamp = "timestamp",
+    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 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']>;
+};
+declare enum BlockRewardStats_OrderBy {
+    AllTimeDistributedBgtAmount = "allTimeDistributedBGTAmount",
+    AllTimeEarnedBgtAmount = "allTimeEarnedBGTAmount",
+    BlockCount = "blockCount",
+    Id = "id",
+    Timestamp = "timestamp",
+    TotalDistributedBgtAmount = "totalDistributedBGTAmount",
+    TotalEarnedBgtAmount = "totalEarnedBGTAmount"
+}
+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>;
+};
+declare enum BlockStatsByValidator_OrderBy {
+    AllTimeBlockCount = "allTimeBlockCount",
+    BlockCount = "blockCount",
+    Id = "id",
+    Timestamp = "timestamp",
+    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 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']>;
+};
+declare enum BlockStats_OrderBy {
+    BlockCount = "blockCount",
+    Id = "id",
+    Timestamp = "timestamp"
+}
+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>;
+};
+declare enum BoostByValidator_OrderBy {
+    AllTimeBoostAmount = "allTimeBoostAmount",
+    AllTimeDropBoostAmount = "allTimeDropBoostAmount",
+    AllTimeNetAmount = "allTimeNetAmount",
+    BoostAmount = "boostAmount",
+    DropBoostAmount = "dropBoostAmount",
+    Id = "id",
+    NetAmount = "netAmount",
+    Timestamp = "timestamp",
+    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 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"
+}
+/** 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'];
+};
+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']>;
+};
+declare enum GlobalRewardDistribution_OrderBy {
+    AllTimeDistributedBgtAmount = "allTimeDistributedBGTAmount",
+    DistributedBgtAmount = "distributedBGTAmount",
+    Id = "id",
+    Timestamp = "timestamp"
+}
+/** 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>;
+};
+declare enum IncentiveDistributionByValidator_OrderBy {
+    AllTimeReceivedTokenAmount = "allTimeReceivedTokenAmount",
+    Id = "id",
+    ReceivedTokenAmount = "receivedTokenAmount",
+    Timestamp = "timestamp",
+    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"
+}
+/** 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>;
+};
+declare enum IncentiveDistributionByVault_OrderBy {
+    AllTimeDistributedTokenAmount = "allTimeDistributedTokenAmount",
+    DistributedTokenAmount = "distributedTokenAmount",
+    Id = "id",
+    Timestamp = "timestamp",
+    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 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']>;
+};
+declare enum IncentiveFeeClaimStats_OrderBy {
+    AllTimePayoutAmount = "allTimePayoutAmount",
+    Id = "id",
+    Timestamp = "timestamp",
+    TotalPayoutAmount = "totalPayoutAmount"
+}
+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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<BlockRewardStatsByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockRewardStatsByValidator_Filter>;
+};
+type QueryBlockRewardStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<BlockRewardStats_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<BlockStatsByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<BlockStatsByValidator_Filter>;
+};
+type QueryBlockStats_CollectionArgs = {
+    block?: InputMaybe<Block_Height>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<BlockStats_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<BoostByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<GlobalRewardDistribution_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<IncentiveDistributionByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    subgraphError?: _SubgraphErrorPolicy_;
+    where?: InputMaybe<IncentiveDistributionByValidator_Filter>;
+};
+type QueryIncentiveDistributionByVaultsArgs = {
+    block?: InputMaybe<Block_Height>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<IncentiveDistributionByVault_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<IncentiveFeeClaimStats_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<RewardDistributionByVault_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<RewardsDistributionByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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>;
+};
+declare enum RewardDistributionByVault_OrderBy {
+    AllTimeReceivedBgtAmount = "allTimeReceivedBGTAmount",
+    Id = "id",
+    ReceivedBgtAmount = "receivedBGTAmount",
+    Timestamp = "timestamp",
+    Vault = "vault",
+    VaultAddress = "vault__address",
+    VaultId = "vault__id",
+    VaultIsWhitelisted = "vault__isWhitelisted",
+    VaultRawMetadata = "vault__rawMetadata",
+    VaultStakingTokenAmount = "vault__stakingTokenAmount",
+    VaultUnscaledStakingTokenAmount = "vault__unscaledStakingTokenAmount"
+}
+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>;
+};
+declare enum RewardsDistributionByValidator_OrderBy {
+    AllTimeDistributedBgtAmount = "allTimeDistributedBGTAmount",
+    DistributedBgtAmount = "distributedBGTAmount",
+    Id = "id",
+    Timestamp = "timestamp",
+    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"
+}
+/** Stores basic info for every token */
+type TokenInformation = {
+    __typename?: 'TokenInformation';
+    activeIncentives?: Maybe<Array<ActiveIncentive>>;
+    address: Scalars['Bytes']['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 = {
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<IncentiveDistributionByVault_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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['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<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 = {
+    current?: InputMaybe<Aggregation_Current>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    interval: Aggregation_Interval;
+    orderBy?: InputMaybe<BoostByValidator_OrderBy>;
+    orderDirection?: InputMaybe<OrderDirection>;
+    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';
+    publicKey: `0x${string}`;
+    activeBoostAmount: string;
+};
+type BoostByValidatorFragment = {
+    __typename?: 'BoostByValidator';
+    allTimeNetAmount: string;
+    netAmount: string;
+    timestamp: string;
+};
+type BlockRewardStatsByValidatorFragment = {
+    __typename?: 'BlockRewardStatsByValidator';
+    timestamp: string;
+    distributedBGTAmount: string;
+    earnedBGTAmount: string;
+    validator: {
+        __typename?: 'Validator';
+        publicKey: `0x${string}`;
+        activeBoostAmount: string;
+    };
+};
+type GetValidatorBlockStatsQueryVariables = Exact<{
+    pubKey: Scalars['Bytes']['input'];
+    first?: InputMaybe<Scalars['Int']['input']>;
+}>;
+type GetValidatorBlockStatsQuery = {
+    __typename?: 'Query';
+    blockStatsByValidators: Array<{
+        __typename?: 'BlockStatsByValidator';
+        blockCount: string;
+        allTimeBlockCount: string;
+        timestamp: string;
+        validator: {
+            __typename?: 'Validator';
+            publicKey: `0x${string}`;
+            activeBoostAmount: string;
+        };
+    }>;
+    blockStats_collection: Array<{
+        __typename?: 'BlockStats';
+        blockCount: string;
+    }>;
+};
+type StakingTokenFragment = {
+    __typename?: 'TokenInformation';
+    address: `0x${string}`;
+    decimals: number;
+    name: string;
+    symbol: string;
+};
+type GetValidatorAnalyticsQueryVariables = Exact<{
+    pubKey: Scalars['Bytes']['input'];
+    timestamp: Scalars['Timestamp']['input'];
+}>;
+type GetValidatorAnalyticsQuery = {
+    __typename?: 'Query';
+    boostByValidators: Array<{
+        __typename?: 'BoostByValidator';
+        allTimeNetAmount: string;
+        netAmount: string;
+        timestamp: string;
+    }>;
+    blockRewardStatsByValidators: Array<{
+        __typename?: 'BlockRewardStatsByValidator';
+        timestamp: string;
+        distributedBGTAmount: string;
+        earnedBGTAmount: string;
+        validator: {
+            __typename?: 'Validator';
+            publicKey: `0x${string}`;
+            activeBoostAmount: string;
+        };
+    }>;
+    incentiveDistributionByValidators: Array<{
+        __typename?: 'IncentiveDistributionByValidator';
+        receivedTokenAmount: string;
+        timestamp: string;
+        token: {
+            __typename?: 'TokenInformation';
+            address: `0x${string}`;
+            decimals: number;
+            name: string;
+            symbol: string;
+        };
+    }>;
+    userValidatorBoostQueued: Array<{
+        __typename?: 'UserBoost';
+        queuedBoostAmount: string;
+        user: `0x${string}`;
+    }>;
+    userValidatorBoostDeposited: Array<{
+        __typename?: 'UserBoost';
+        activeBoostAmount: string;
+        user: `0x${string}`;
+    }>;
+};
+type GetIncentiveFeeClaimStatsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+type GetIncentiveFeeClaimStatsQuery = {
+    __typename?: 'Query';
+    incentiveFeeClaims: Array<{
+        __typename?: 'IncentiveFeeClaim';
+        recipient: `0x${string}`;
+        payoutAmount: string;
+        timestamp: string;
+    }>;
+};
+/** 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 StakingToken: _apollo_client.DocumentNode;
+declare const GetValidatorBlockStats: _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_Current, Aggregation_Interval, type BlockChangedFilter, type BlockReward, type BlockRewardStats, BlockRewardStatsByValidator, type BlockRewardStatsByValidatorFragment, type BlockRewardStatsByValidator_Filter, BlockRewardStatsByValidator_OrderBy, type BlockRewardStats_Filter, BlockRewardStats_OrderBy, type BlockReward_Filter, BlockReward_OrderBy, type BlockStats, type BlockStatsByValidator, type BlockStatsByValidator_Filter, BlockStatsByValidator_OrderBy, type BlockStats_Filter, BlockStats_OrderBy, type Block_Height, type Boost, BoostByValidator, type BoostByValidatorFragment, type BoostByValidator_Filter, BoostByValidator_OrderBy, type Boost_Filter, Boost_OrderBy, type Exact, GetIncentiveFeeClaimStats, type GetIncentiveFeeClaimStatsQuery, type GetIncentiveFeeClaimStatsQueryVariables, GetValidatorAnalytics, type GetValidatorAnalyticsQuery, type GetValidatorAnalyticsQueryVariables, GetValidatorBlockStats, type GetValidatorBlockStatsQuery, type GetValidatorBlockStatsQueryVariables, type GlobalInfo, type GlobalInfo_Filter, GlobalInfo_OrderBy, type GlobalRewardDistribution, type GlobalRewardDistribution_Filter, GlobalRewardDistribution_OrderBy, type IncentiveDistribution, type IncentiveDistributionByValidator, type IncentiveDistributionByValidator_Filter, IncentiveDistributionByValidator_OrderBy, type IncentiveDistributionByVault, type IncentiveDistributionByVault_Filter, IncentiveDistributionByVault_OrderBy, type IncentiveDistribution_Filter, IncentiveDistribution_OrderBy, type IncentiveFeeClaim, type IncentiveFeeClaimStats, type IncentiveFeeClaimStats_Filter, IncentiveFeeClaimStats_OrderBy, 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, RewardDistributionByVault_OrderBy, type RewardDistribution_Filter, RewardDistribution_OrderBy, type RewardsDistributionByValidator, type RewardsDistributionByValidator_Filter, RewardsDistributionByValidator_OrderBy, type Scalars, StakingToken, type StakingTokenFragment, 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, type VaultRewardAllocationWeightsArgs, type VaultStakedUsersArgs, type VaultWhitelistedTokensArgs, type Vault_Filter, Vault_OrderBy, type WhitelistedToken, type WhitelistedToken_Filter, WhitelistedToken_OrderBy, type _Block_, type _Meta_, _SubgraphErrorPolicy_, result as default };