@keyban/sdk-base/dist/graphql.d.mts

Keyban Javascript SDK provides core functionalities for the MPC wallet solution, supporting web and Node.js apps with TypeScript, custom storage, and Ethereum blockchain integration.

import { TypedDocumentNode } from '@graphql-typed-document-node/core';

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;
    };
    BigFloat: {
        input: string;
        output: string;
    };
    BigInt: {
        input: string;
        output: string;
    };
    Cursor: {
        input: string;
        output: string;
    };
    Date: {
        input: string;
        output: string;
    };
    Datetime: {
        input: string;
        output: string;
    };
    JSON: {
        input: any;
        output: any;
    };
};
type GqlAssetTransfer = GqlNode & {
    decimals: Maybe<Scalars['Int']['output']>;
    /** Reads a single `Wallet` that is related to this `AssetTransfer`. */
    from: Maybe<GqlWallet>;
    fromId: Scalars['String']['output'];
    id: Scalars['String']['output'];
    /** Reads a single `Nft` that is related to this `AssetTransfer`. */
    nft: Maybe<GqlNft>;
    nftId: Maybe<Scalars['String']['output']>;
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID']['output'];
    /** Reads a single `Wallet` that is related to this `AssetTransfer`. */
    to: Maybe<GqlWallet>;
    toId: Maybe<Scalars['String']['output']>;
    /** Reads a single `TokenContract` that is related to this `AssetTransfer`. */
    token: Maybe<GqlTokenContract>;
    tokenId: Maybe<Scalars['String']['output']>;
    /** Reads a single `Transaction` that is related to this `AssetTransfer`. */
    transaction: Maybe<GqlTransaction>;
    transactionBlockNumber: Scalars['BigFloat']['output'];
    transactionId: Scalars['String']['output'];
    type: Scalars['String']['output'];
    value: Scalars['BigFloat']['output'];
};
type GqlAssetTransferAggregates = {
    /** Mean average aggregates across the matching connection (ignoring before/after/first/last/offset) */
    average: Maybe<GqlAssetTransferAverageAggregates>;
    /** Distinct count aggregates across the matching connection (ignoring before/after/first/last/offset) */
    distinctCount: Maybe<GqlAssetTransferDistinctCountAggregates>;
    keys: Maybe<Array<Scalars['String']['output']>>;
    /** Maximum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    max: Maybe<GqlAssetTransferMaxAggregates>;
    /** Minimum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    min: Maybe<GqlAssetTransferMinAggregates>;
    /** Population standard deviation aggregates across the matching connection (ignoring before/after/first/last/offset) */
    stddevPopulation: Maybe<GqlAssetTransferStddevPopulationAggregates>;
    /** Sample standard deviation aggregates across the matching connection (ignoring before/after/first/last/offset) */
    stddevSample: Maybe<GqlAssetTransferStddevSampleAggregates>;
    /** Sum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    sum: Maybe<GqlAssetTransferSumAggregates>;
    /** Population variance aggregates across the matching connection (ignoring before/after/first/last/offset) */
    variancePopulation: Maybe<GqlAssetTransferVariancePopulationAggregates>;
    /** Sample variance aggregates across the matching connection (ignoring before/after/first/last/offset) */
    varianceSample: Maybe<GqlAssetTransferVarianceSampleAggregates>;
};
/** A filter to be used against aggregates of `AssetTransfer` object types. */
type GqlAssetTransferAggregatesFilter = {
    /** Mean average aggregate over matching `AssetTransfer` objects. */
    average?: InputMaybe<GqlAssetTransferAverageAggregateFilter>;
    /** Distinct count aggregate over matching `AssetTransfer` objects. */
    distinctCount?: InputMaybe<GqlAssetTransferDistinctCountAggregateFilter>;
    /** A filter that must pass for the relevant `AssetTransfer` object to be included within the aggregate. */
    filter?: InputMaybe<GqlAssetTransferFilter>;
    /** Maximum aggregate over matching `AssetTransfer` objects. */
    max?: InputMaybe<GqlAssetTransferMaxAggregateFilter>;
    /** Minimum aggregate over matching `AssetTransfer` objects. */
    min?: InputMaybe<GqlAssetTransferMinAggregateFilter>;
    /** Population standard deviation aggregate over matching `AssetTransfer` objects. */
    stddevPopulation?: InputMaybe<GqlAssetTransferStddevPopulationAggregateFilter>;
    /** Sample standard deviation aggregate over matching `AssetTransfer` objects. */
    stddevSample?: InputMaybe<GqlAssetTransferStddevSampleAggregateFilter>;
    /** Sum aggregate over matching `AssetTransfer` objects. */
    sum?: InputMaybe<GqlAssetTransferSumAggregateFilter>;
    /** Population variance aggregate over matching `AssetTransfer` objects. */
    variancePopulation?: InputMaybe<GqlAssetTransferVariancePopulationAggregateFilter>;
    /** Sample variance aggregate over matching `AssetTransfer` objects. */
    varianceSample?: InputMaybe<GqlAssetTransferVarianceSampleAggregateFilter>;
};
type GqlAssetTransferAverageAggregateFilter = {
    decimals?: InputMaybe<GqlBigFloatFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferAverageAggregates = {
    /** Mean average of decimals across the matching connection */
    decimals: Maybe<Scalars['BigFloat']['output']>;
    /** Mean average of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Mean average of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
type GqlAssetTransferDistinctCountAggregateFilter = {
    _blockRange?: InputMaybe<GqlBigIntFilter>;
    _id?: InputMaybe<GqlBigIntFilter>;
    decimals?: InputMaybe<GqlBigIntFilter>;
    fromId?: InputMaybe<GqlBigIntFilter>;
    id?: InputMaybe<GqlBigIntFilter>;
    nftId?: InputMaybe<GqlBigIntFilter>;
    toId?: InputMaybe<GqlBigIntFilter>;
    tokenId?: InputMaybe<GqlBigIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigIntFilter>;
    transactionId?: InputMaybe<GqlBigIntFilter>;
    type?: InputMaybe<GqlBigIntFilter>;
    value?: InputMaybe<GqlBigIntFilter>;
};
type GqlAssetTransferDistinctCountAggregates = {
    /** Distinct count of _blockRange across the matching connection */
    _blockRange: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of _id across the matching connection */
    _id: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of decimals across the matching connection */
    decimals: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of fromId across the matching connection */
    fromId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of id across the matching connection */
    id: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of nftId across the matching connection */
    nftId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of toId across the matching connection */
    toId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of tokenId across the matching connection */
    tokenId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of transactionId across the matching connection */
    transactionId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of type across the matching connection */
    type: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of value across the matching connection */
    value: Maybe<Scalars['BigInt']['output']>;
};
/** A filter to be used against `AssetTransfer` object types. All fields are combined with a logical ‘and.’ */
type GqlAssetTransferFilter = {
    /** Checks for all expressions in this list. */
    and?: InputMaybe<Array<GqlAssetTransferFilter>>;
    /** Filter by the object’s `decimals` field. */
    decimals?: InputMaybe<GqlIntFilter>;
    /** Filter by the object’s `from` relation. */
    from?: InputMaybe<GqlWalletFilter>;
    /** Filter by the object’s `fromId` field. */
    fromId?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `id` field. */
    id?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `nft` relation. */
    nft?: InputMaybe<GqlNftFilter>;
    /** A related `nft` exists. */
    nftExists?: InputMaybe<Scalars['Boolean']['input']>;
    /** Filter by the object’s `nftId` field. */
    nftId?: InputMaybe<GqlStringFilter>;
    /** Negates the expression. */
    not?: InputMaybe<GqlAssetTransferFilter>;
    /** Checks for any expressions in this list. */
    or?: InputMaybe<Array<GqlAssetTransferFilter>>;
    /** Filter by the object’s `to` relation. */
    to?: InputMaybe<GqlWalletFilter>;
    /** A related `to` exists. */
    toExists?: InputMaybe<Scalars['Boolean']['input']>;
    /** Filter by the object’s `toId` field. */
    toId?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `token` relation. */
    token?: InputMaybe<GqlTokenContractFilter>;
    /** A related `token` exists. */
    tokenExists?: InputMaybe<Scalars['Boolean']['input']>;
    /** Filter by the object’s `tokenId` field. */
    tokenId?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `transaction` relation. */
    transaction?: InputMaybe<GqlTransactionFilter>;
    /** Filter by the object’s `transactionBlockNumber` field. */
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    /** Filter by the object’s `transactionId` field. */
    transactionId?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `type` field. */
    type?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `value` field. */
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferMaxAggregateFilter = {
    decimals?: InputMaybe<GqlIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferMaxAggregates = {
    /** Maximum of decimals across the matching connection */
    decimals: Maybe<Scalars['Int']['output']>;
    /** Maximum of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Maximum of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
type GqlAssetTransferMinAggregateFilter = {
    decimals?: InputMaybe<GqlIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferMinAggregates = {
    /** Minimum of decimals across the matching connection */
    decimals: Maybe<Scalars['Int']['output']>;
    /** Minimum of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Minimum of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
type GqlAssetTransferPayload = {
    _entity: Maybe<GqlAssetTransfer>;
    id: Scalars['ID']['output'];
    mutation_type: GqlMutationType;
};
type GqlAssetTransferPayload_entityArgs = {
    distinct?: InputMaybe<Array<InputMaybe<Gqlasset_transfers_distinct_enum>>>;
};
type GqlAssetTransferStddevPopulationAggregateFilter = {
    decimals?: InputMaybe<GqlBigFloatFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferStddevPopulationAggregates = {
    /** Population standard deviation of decimals across the matching connection */
    decimals: Maybe<Scalars['BigFloat']['output']>;
    /** Population standard deviation of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Population standard deviation of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
type GqlAssetTransferStddevSampleAggregateFilter = {
    decimals?: InputMaybe<GqlBigFloatFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferStddevSampleAggregates = {
    /** Sample standard deviation of decimals across the matching connection */
    decimals: Maybe<Scalars['BigFloat']['output']>;
    /** Sample standard deviation of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Sample standard deviation of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
type GqlAssetTransferSumAggregateFilter = {
    decimals?: InputMaybe<GqlBigIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferSumAggregates = {
    /** Sum of decimals across the matching connection */
    decimals: Scalars['BigInt']['output'];
    /** Sum of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Scalars['BigFloat']['output'];
    /** Sum of value across the matching connection */
    value: Scalars['BigFloat']['output'];
};
type GqlAssetTransferVariancePopulationAggregateFilter = {
    decimals?: InputMaybe<GqlBigFloatFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferVariancePopulationAggregates = {
    /** Population variance of decimals across the matching connection */
    decimals: Maybe<Scalars['BigFloat']['output']>;
    /** Population variance of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Population variance of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
type GqlAssetTransferVarianceSampleAggregateFilter = {
    decimals?: InputMaybe<GqlBigFloatFilter>;
    transactionBlockNumber?: InputMaybe<GqlBigFloatFilter>;
    value?: InputMaybe<GqlBigFloatFilter>;
};
type GqlAssetTransferVarianceSampleAggregates = {
    /** Sample variance of decimals across the matching connection */
    decimals: Maybe<Scalars['BigFloat']['output']>;
    /** Sample variance of transactionBlockNumber across the matching connection */
    transactionBlockNumber: Maybe<Scalars['BigFloat']['output']>;
    /** Sample variance of value across the matching connection */
    value: Maybe<Scalars['BigFloat']['output']>;
};
/** A connection to a list of `AssetTransfer` values. */
type GqlAssetTransfersConnection = {
    /** Aggregates across the matching connection (ignoring before/after/first/last/offset) */
    aggregates: Maybe<GqlAssetTransferAggregates>;
    /** A list of edges which contains the `AssetTransfer` and cursor to aid in pagination. */
    edges: Array<GqlAssetTransfersEdge>;
    /** Grouped aggregates across the matching connection (ignoring before/after/first/last/offset) */
    groupedAggregates: Maybe<Array<GqlAssetTransferAggregates>>;
    /** A list of `AssetTransfer` objects. */
    nodes: Array<Maybe<GqlAssetTransfer>>;
    /** Information to aid in pagination. */
    pageInfo: GqlPageInfo;
    /** The count of *all* `AssetTransfer` you could get from the connection. */
    totalCount: Scalars['Int']['output'];
};
/** A connection to a list of `AssetTransfer` values. */
type GqlAssetTransfersConnectiongroupedAggregatesArgs = {
    groupBy: Array<GqlAssetTransfersGroupBy>;
    having?: InputMaybe<GqlAssetTransfersHavingInput>;
};
/** A `AssetTransfer` edge in the connection. */
type GqlAssetTransfersEdge = {
    /** A cursor for use in pagination. */
    cursor: Maybe<Scalars['Cursor']['output']>;
    /** The `AssetTransfer` at the end of the edge. */
    node: Maybe<GqlAssetTransfer>;
};
/** Grouping methods for `AssetTransfer` for usage during aggregation. */
declare enum GqlAssetTransfersGroupBy {
    DECIMALS = "DECIMALS",
    FROM_ID = "FROM_ID",
    ID = "ID",
    NFT_ID = "NFT_ID",
    TOKEN_ID = "TOKEN_ID",
    TO_ID = "TO_ID",
    TRANSACTION_BLOCK_NUMBER = "TRANSACTION_BLOCK_NUMBER",
    TRANSACTION_ID = "TRANSACTION_ID",
    TYPE = "TYPE",
    VALUE = "VALUE"
}
type GqlAssetTransfersHavingAverageInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingDistinctCountInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
/** Conditions for `AssetTransfer` aggregates. */
type GqlAssetTransfersHavingInput = {
    AND?: InputMaybe<Array<GqlAssetTransfersHavingInput>>;
    OR?: InputMaybe<Array<GqlAssetTransfersHavingInput>>;
    average?: InputMaybe<GqlAssetTransfersHavingAverageInput>;
    distinctCount?: InputMaybe<GqlAssetTransfersHavingDistinctCountInput>;
    max?: InputMaybe<GqlAssetTransfersHavingMaxInput>;
    min?: InputMaybe<GqlAssetTransfersHavingMinInput>;
    stddevPopulation?: InputMaybe<GqlAssetTransfersHavingStddevPopulationInput>;
    stddevSample?: InputMaybe<GqlAssetTransfersHavingStddevSampleInput>;
    sum?: InputMaybe<GqlAssetTransfersHavingSumInput>;
    variancePopulation?: InputMaybe<GqlAssetTransfersHavingVariancePopulationInput>;
    varianceSample?: InputMaybe<GqlAssetTransfersHavingVarianceSampleInput>;
};
type GqlAssetTransfersHavingMaxInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingMinInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingStddevPopulationInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingStddevSampleInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingSumInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingVariancePopulationInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
type GqlAssetTransfersHavingVarianceSampleInput = {
    decimals?: InputMaybe<GqlHavingIntFilter>;
    transactionBlockNumber?: InputMaybe<GqlHavingBigfloatFilter>;
    value?: InputMaybe<GqlHavingBigfloatFilter>;
};
/** Methods to use when ordering `AssetTransfer`. */
declare enum GqlAssetTransfersOrderBy {
    DECIMALS_ASC = "DECIMALS_ASC",
    DECIMALS_DESC = "DECIMALS_DESC",
    FROM_ID_ASC = "FROM_ID_ASC",
    FROM_ID_DESC = "FROM_ID_DESC",
    ID_ASC = "ID_ASC",
    ID_DESC = "ID_DESC",
    NATURAL = "NATURAL",
    NFT_BY_NFT_ID__COLLECTION_ID_ASC = "NFT_BY_NFT_ID__COLLECTION_ID_ASC",
    NFT_BY_NFT_ID__COLLECTION_ID_DESC = "NFT_BY_NFT_ID__COLLECTION_ID_DESC",
    NFT_BY_NFT_ID__ID_ASC = "NFT_BY_NFT_ID__ID_ASC",
    NFT_BY_NFT_ID__ID_DESC = "NFT_BY_NFT_ID__ID_DESC",
    NFT_BY_NFT_ID__METADATA_ASC = "NFT_BY_NFT_ID__METADATA_ASC",
    NFT_BY_NFT_ID__METADATA_DESC = "NFT_BY_NFT_ID__METADATA_DESC",
    NFT_BY_NFT_ID__TOKEN_ID_ASC = "NFT_BY_NFT_ID__TOKEN_ID_ASC",
    NFT_BY_NFT_ID__TOKEN_ID_DESC = "NFT_BY_NFT_ID__TOKEN_ID_DESC",
    NFT_ID_ASC = "NFT_ID_ASC",
    NFT_ID_DESC = "NFT_ID_DESC",
    PRIMARY_KEY_ASC = "PRIMARY_KEY_ASC",
    PRIMARY_KEY_DESC = "PRIMARY_KEY_DESC",
    TOKEN_CONTRACT_BY_TOKEN_ID__DECIMALS_ASC = "TOKEN_CONTRACT_BY_TOKEN_ID__DECIMALS_ASC",
    TOKEN_CONTRACT_BY_TOKEN_ID__DECIMALS_DESC = "TOKEN_CONTRACT_BY_TOKEN_ID__DECIMALS_DESC",
    TOKEN_CONTRACT_BY_TOKEN_ID__ICON_URL_ASC = "TOKEN_CONTRACT_BY_TOKEN_ID__ICON_URL_ASC",
    TOKEN_CONTRACT_BY_TOKEN_ID__ICON_URL_DESC = "TOKEN_CONTRACT_BY_TOKEN_ID__ICON_URL_DESC",
    TOKEN_CONTRACT_BY_TOKEN_ID__ID_ASC = "TOKEN_CONTRACT_BY_TOKEN_ID__ID_ASC",
    TOKEN_CONTRACT_BY_TOKEN_ID__ID_DESC = "TOKEN_CONTRACT_BY_TOKEN_ID__ID_DESC",
    TOKEN_CONTRACT_BY_TOKEN_ID__NAME_ASC = "TOKEN_CONTRACT_BY_TOKEN_ID__NAME_ASC",
    TOKEN_CONTRACT_BY_TOKEN_ID__NAME_DESC = "TOKEN_CONTRACT_BY_TOKEN_ID__NAME_DESC",
    TOKEN_CONTRACT_BY_TOKEN_ID__SYMBOL_ASC = "TOKEN_CONTRACT_BY_TOKEN_ID__SYMBOL_ASC",
    TOKEN_CONTRACT_BY_TOKEN_ID__SYMBOL_DESC = "TOKEN_CONTRACT_BY_TOKEN_ID__SYMBOL_DESC",
    TOKEN_CONTRACT_BY_TOKEN_ID__TYPE_ASC = "TOKEN_CONTRACT_BY_TOKEN_ID__TYPE_ASC",
    TOKEN_CONTRACT_BY_TOKEN_ID__TYPE_DESC = "TOKEN_CONTRACT_BY_TOKEN_ID__TYPE_DESC",
    TOKEN_ID_ASC = "TOKEN_ID_ASC",
    TOKEN_ID_DESC = "TOKEN_ID_DESC",
    TO_ID_ASC = "TO_ID_ASC",
    TO_ID_DESC = "TO_ID_DESC",
    TRANSACTION_BLOCK_NUMBER_ASC = "TRANSACTION_BLOCK_NUMBER_ASC",
    TRANSACTION_BLOCK_NUMBER_DESC = "TRANSACTION_BLOCK_NUMBER_DESC",
    TRANSACTION_BY_TRANSACTION_ID__BLOCK_HASH_ASC = "TRANSACTION_BY_TRANSACTION_ID__BLOCK_HASH_ASC",
    TRANSACTION_BY_TRANSACTION_ID__BLOCK_HASH_DESC = "TRANSACTION_BY_TRANSACTION_ID__BLOCK_HASH_DESC",
    TRANSACTION_BY_TRANSACTION_ID__BLOCK_NUMBER_ASC = "TRANSACTION_BY_TRANSACTION_ID__BLOCK_NUMBER_ASC",
    TRANSACTION_BY_TRANSACTION_ID__BLOCK_NUMBER_DESC = "TRANSACTION_BY_TRANSACTION_ID__BLOCK_NUMBER_DESC",
    TRANSACTION_BY_TRANSACTION_ID__DATE_ASC = "TRANSACTION_BY_TRANSACTION_ID__DATE_ASC",
    TRANSACTION_BY_TRANSACTION_ID__DATE_DESC = "TRANSACTION_BY_TRANSACTION_ID__DATE_DESC",
    TRANSACTION_BY_TRANSACTION_ID__FEES_ASC = "TRANSACTION_BY_TRANSACTION_ID__FEES_ASC",
    TRANSACTION_BY_TRANSACTION_ID__FEES_DESC = "TRANSACTION_BY_TRANSACTION_ID__FEES_DESC",
    TRANSACTION_BY_TRANSACTION_ID__GAS_PRICE_ASC = "TRANSACTION_BY_TRANSACTION_ID__GAS_PRICE_ASC",
    TRANSACTION_BY_TRANSACTION_ID__GAS_PRICE_DESC = "TRANSACTION_BY_TRANSACTION_ID__GAS_PRICE_DESC",
    TRANSACTION_BY_TRANSACTION_ID__GAS_USED_ASC = "TRANSACTION_BY_TRANSACTION_ID__GAS_USED_ASC",
    TRANSACTION_BY_TRANSACTION_ID__GAS_USED_DESC = "TRANSACTION_BY_TRANSACTION_ID__GAS_USED_DESC",
    TRANSACTION_BY_TRANSACTION_ID__ID_ASC = "TRANSACTION_BY_TRANSACTION_ID__ID_ASC",
    TRANSACTION_BY_TRANSACTION_ID__ID_DESC = "TRANSACTION_BY_TRANSACTION_ID__ID_DESC",
    TRANSACTION_BY_TRANSACTION_ID__SUCCESS_ASC = "TRANSACTION_BY_TRANSACTION_ID__SUCCESS_ASC",
    TRANSACTION_BY_TRANSACTION_ID__SUCCESS_DESC = "TRANSACTION_BY_TRANSACTION_ID__SUCCESS_DESC",
    TRANSACTION_ID_ASC = "TRANSACTION_ID_ASC",
    TRANSACTION_ID_DESC = "TRANSACTION_ID_DESC",
    TYPE_ASC = "TYPE_ASC",
    TYPE_DESC = "TYPE_DESC",
    VALUE_ASC = "VALUE_ASC",
    VALUE_DESC = "VALUE_DESC",
    WALLET_BY_FROM_ID__BALANCE_ASC = "WALLET_BY_FROM_ID__BALANCE_ASC",
    WALLET_BY_FROM_ID__BALANCE_DESC = "WALLET_BY_FROM_ID__BALANCE_DESC",
    WALLET_BY_FROM_ID__ID_ASC = "WALLET_BY_FROM_ID__ID_ASC",
    WALLET_BY_FROM_ID__ID_DESC = "WALLET_BY_FROM_ID__ID_DESC",
    WALLET_BY_TO_ID__BALANCE_ASC = "WALLET_BY_TO_ID__BALANCE_ASC",
    WALLET_BY_TO_ID__BALANCE_DESC = "WALLET_BY_TO_ID__BALANCE_DESC",
    WALLET_BY_TO_ID__ID_ASC = "WALLET_BY_TO_ID__ID_ASC",
    WALLET_BY_TO_ID__ID_DESC = "WALLET_BY_TO_ID__ID_DESC"
}
/** A filter to be used against BigFloat fields. All fields are combined with a logical ‘and.’ */
type GqlBigFloatFilter = {
    /** Not equal to the specified value, treating null like an ordinary value. */
    distinctFrom?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Equal to the specified value. */
    equalTo?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['BigFloat']['input']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Equal to the specified value, treating null like an ordinary value. */
    notDistinctFrom?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Not equal to the specified value. */
    notEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    /** Not included in the specified list. */
    notIn?: InputMaybe<Array<Scalars['BigFloat']['input']>>;
};
/** A filter to be used against BigInt fields. All fields are combined with a logical ‘and.’ */
type GqlBigIntFilter = {
    /** Not equal to the specified value, treating null like an ordinary value. */
    distinctFrom?: InputMaybe<Scalars['BigInt']['input']>;
    /** Equal to the specified value. */
    equalTo?: InputMaybe<Scalars['BigInt']['input']>;
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['BigInt']['input']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['BigInt']['input']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    /** Equal to the specified value, treating null like an ordinary value. */
    notDistinctFrom?: InputMaybe<Scalars['BigInt']['input']>;
    /** Not equal to the specified value. */
    notEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    /** Not included in the specified list. */
    notIn?: InputMaybe<Array<Scalars['BigInt']['input']>>;
};
/** A filter to be used against Boolean fields. All fields are combined with a logical ‘and.’ */
type GqlBooleanFilter = {
    /** Not equal to the specified value, treating null like an ordinary value. */
    distinctFrom?: InputMaybe<Scalars['Boolean']['input']>;
    /** Equal to the specified value. */
    equalTo?: InputMaybe<Scalars['Boolean']['input']>;
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['Boolean']['input']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
    /** Equal to the specified value, treating null like an ordinary value. */
    notDistinctFrom?: InputMaybe<Scalars['Boolean']['input']>;
    /** Not equal to the specified value. */
    notEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
    /** Not included in the specified list. */
    notIn?: InputMaybe<Array<Scalars['Boolean']['input']>>;
};
/** A filter to be used against Datetime fields. All fields are combined with a logical ‘and.’ */
type GqlDatetimeFilter = {
    /** Not equal to the specified value, treating null like an ordinary value. */
    distinctFrom?: InputMaybe<Scalars['Datetime']['input']>;
    /** Equal to the specified value. */
    equalTo?: InputMaybe<Scalars['Datetime']['input']>;
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['Datetime']['input']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['Datetime']['input']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['Datetime']['input']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    /** Equal to the specified value, treating null like an ordinary value. */
    notDistinctFrom?: InputMaybe<Scalars['Datetime']['input']>;
    /** Not equal to the specified value. */
    notEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    /** Not included in the specified list. */
    notIn?: InputMaybe<Array<Scalars['Datetime']['input']>>;
};
type GqlHavingBigfloatFilter = {
    equalTo?: InputMaybe<Scalars['BigFloat']['input']>;
    greaterThan?: InputMaybe<Scalars['BigFloat']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    lessThan?: InputMaybe<Scalars['BigFloat']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    notEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
};
type GqlHavingDatetimeFilter = {
    equalTo?: InputMaybe<Scalars['Datetime']['input']>;
    greaterThan?: InputMaybe<Scalars['Datetime']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    lessThan?: InputMaybe<Scalars['Datetime']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    notEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
};
type GqlHavingIntFilter = {
    equalTo?: InputMaybe<Scalars['Int']['input']>;
    greaterThan?: InputMaybe<Scalars['Int']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    lessThan?: InputMaybe<Scalars['Int']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    notEqualTo?: InputMaybe<Scalars['Int']['input']>;
};
/** A filter to be used against Int fields. All fields are combined with a logical ‘and.’ */
type GqlIntFilter = {
    /** Not equal to the specified value, treating null like an ordinary value. */
    distinctFrom?: InputMaybe<Scalars['Int']['input']>;
    /** Equal to the specified value. */
    equalTo?: InputMaybe<Scalars['Int']['input']>;
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['Int']['input']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['Int']['input']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['Int']['input']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    /** Equal to the specified value, treating null like an ordinary value. */
    notDistinctFrom?: InputMaybe<Scalars['Int']['input']>;
    /** Not equal to the specified value. */
    notEqualTo?: InputMaybe<Scalars['Int']['input']>;
    /** Not included in the specified list. */
    notIn?: InputMaybe<Array<Scalars['Int']['input']>>;
};
/** A filter to be used against JSON fields. All fields are combined with a logical ‘and.’ */
type GqlJSONFilter = {
    /** Contained by the specified JSON. */
    containedBy?: InputMaybe<Scalars['JSON']['input']>;
    /** Contains the specified JSON. */
    contains?: InputMaybe<Scalars['JSON']['input']>;
    /** Contains all of the specified keys. */
    containsAllKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Contains any of the specified keys. */
    containsAnyKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Contains the specified key. */
    containsKey?: InputMaybe<Scalars['String']['input']>;
    /** Not equal to the specified value, treating null like an ordinary value. */
    distinctFrom?: InputMaybe<Scalars['JSON']['input']>;
    /** Equal to the specified value. */
    equalTo?: InputMaybe<Scalars['JSON']['input']>;
    /** Greater than the specified value. */
    greaterThan?: InputMaybe<Scalars['JSON']['input']>;
    /** Greater than or equal to the specified value. */
    greaterThanOrEqualTo?: InputMaybe<Scalars['JSON']['input']>;
    /** Included in the specified list. */
    in?: InputMaybe<Array<Scalars['JSON']['input']>>;
    /** Is null (if `true` is specified) or is not null (if `false` is specified). */
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    /** Less than the specified value. */
    lessThan?: InputMaybe<Scalars['JSON']['input']>;
    /** Less than or equal to the specified value. */
    lessThanOrEqualTo?: InputMaybe<Scalars['JSON']['input']>;
    /** Equal to the specified value, treating null like an ordinary value. */
    notDistinctFrom?: InputMaybe<Scalars['JSON']['input']>;
    /** Not equal to the specified value. */
    notEqualTo?: InputMaybe<Scalars['JSON']['input']>;
    /** Not included in the specified list. */
    notIn?: InputMaybe<Array<Scalars['JSON']['input']>>;
};
declare enum GqlMutationType {
    DELETE = "DELETE",
    INSERT = "INSERT",
    UPDATE = "UPDATE"
}
type GqlNft = GqlNode & {
    /** Reads and enables pagination through a set of `AssetTransfer`. */
    assetTransfers: GqlAssetTransfersConnection;
    /** Reads a single `TokenContract` that is related to this `Nft`. */
    collection: Maybe<GqlTokenContract>;
    collectionId: Scalars['String']['output'];
    id: Scalars['String']['output'];
    metadata: Scalars['JSON']['output'];
    /** Reads and enables pagination through a set of `NftBalance`. */
    nftBalances: GqlNftBalancesConnection;
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID']['output'];
    /** Reads and enables pagination through a set of `TokenContract`. */
    tokenContractsByAssetTransferNftIdAndTokenId: GqlNftTokenContractsByAssetTransferNftIdAndTokenIdManyToManyConnection;
    tokenId: Scalars['BigFloat']['output'];
    /** Reads and enables pagination through a set of `Transaction`. */
    transactionsByAssetTransferNftIdAndTransactionId: GqlNftTransactionsByAssetTransferNftIdAndTransactionIdManyToManyConnection;
    /** Reads and enables pagination through a set of `Wallet`. */
    walletsByAssetTransferNftIdAndFromId: GqlNftWalletsByAssetTransferNftIdAndFromIdManyToManyConnection;
    /** Reads and enables pagination through a set of `Wallet`. */
    walletsByAssetTransferNftIdAndToId: GqlNftWalletsByAssetTransferNftIdAndToIdManyToManyConnection;
    /** Reads and enables pagination through a set of `Wallet`. */
    walletsByNftBalanceNftIdAndWalletId: GqlNftWalletsByNftBalanceNftIdAndWalletIdManyToManyConnection;
};
type GqlNftassetTransfersArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqlasset_transfers_distinct_enum>>>;
    filter?: InputMaybe<GqlAssetTransferFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlAssetTransfersOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNftnftBalancesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqlnft_balances_distinct_enum>>>;
    filter?: InputMaybe<GqlNftBalanceFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlNftBalancesOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNfttokenContractsByAssetTransferNftIdAndTokenIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqltoken_contracts_distinct_enum>>>;
    filter?: InputMaybe<GqlTokenContractFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlTokenContractsOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNfttransactionsByAssetTransferNftIdAndTransactionIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqltransactions_distinct_enum>>>;
    filter?: InputMaybe<GqlTransactionFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlTransactionsOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNftwalletsByAssetTransferNftIdAndFromIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqlwallets_distinct_enum>>>;
    filter?: InputMaybe<GqlWalletFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlWalletsOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNftwalletsByAssetTransferNftIdAndToIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqlwallets_distinct_enum>>>;
    filter?: InputMaybe<GqlWalletFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlWalletsOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNftwalletsByNftBalanceNftIdAndWalletIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    blockHeight?: InputMaybe<Scalars['String']['input']>;
    distinct?: InputMaybe<Array<InputMaybe<Gqlwallets_distinct_enum>>>;
    filter?: InputMaybe<GqlWalletFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<GqlWalletsOrderBy>>;
    orderByNull?: InputMaybe<GqlNullOrder>;
};
type GqlNftAggregates = {
    /** Mean average aggregates across the matching connection (ignoring before/after/first/last/offset) */
    average: Maybe<GqlNftAverageAggregates>;
    /** Distinct count aggregates across the matching connection (ignoring before/after/first/last/offset) */
    distinctCount: Maybe<GqlNftDistinctCountAggregates>;
    keys: Maybe<Array<Scalars['String']['output']>>;
    /** Maximum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    max: Maybe<GqlNftMaxAggregates>;
    /** Minimum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    min: Maybe<GqlNftMinAggregates>;
    /** Population standard deviation aggregates across the matching connection (ignoring before/after/first/last/offset) */
    stddevPopulation: Maybe<GqlNftStddevPopulationAggregates>;
    /** Sample standard deviation aggregates across the matching connection (ignoring before/after/first/last/offset) */
    stddevSample: Maybe<GqlNftStddevSampleAggregates>;
    /** Sum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    sum: Maybe<GqlNftSumAggregates>;
    /** Population variance aggregates across the matching connection (ignoring before/after/first/last/offset) */
    variancePopulation: Maybe<GqlNftVariancePopulationAggregates>;
    /** Sample variance aggregates across the matching connection (ignoring before/after/first/last/offset) */
    varianceSample: Maybe<GqlNftVarianceSampleAggregates>;
};
/** A filter to be used against aggregates of `Nft` object types. */
type GqlNftAggregatesFilter = {
    /** Mean average aggregate over matching `Nft` objects. */
    average?: InputMaybe<GqlNftAverageAggregateFilter>;
    /** Distinct count aggregate over matching `Nft` objects. */
    distinctCount?: InputMaybe<GqlNftDistinctCountAggregateFilter>;
    /** A filter that must pass for the relevant `Nft` object to be included within the aggregate. */
    filter?: InputMaybe<GqlNftFilter>;
    /** Maximum aggregate over matching `Nft` objects. */
    max?: InputMaybe<GqlNftMaxAggregateFilter>;
    /** Minimum aggregate over matching `Nft` objects. */
    min?: InputMaybe<GqlNftMinAggregateFilter>;
    /** Population standard deviation aggregate over matching `Nft` objects. */
    stddevPopulation?: InputMaybe<GqlNftStddevPopulationAggregateFilter>;
    /** Sample standard deviation aggregate over matching `Nft` objects. */
    stddevSample?: InputMaybe<GqlNftStddevSampleAggregateFilter>;
    /** Sum aggregate over matching `Nft` objects. */
    sum?: InputMaybe<GqlNftSumAggregateFilter>;
    /** Population variance aggregate over matching `Nft` objects. */
    variancePopulation?: InputMaybe<GqlNftVariancePopulationAggregateFilter>;
    /** Sample variance aggregate over matching `Nft` objects. */
    varianceSample?: InputMaybe<GqlNftVarianceSampleAggregateFilter>;
};
type GqlNftAverageAggregateFilter = {
    tokenId?: InputMaybe<GqlBigFloatFilter>;
};
type GqlNftAverageAggregates = {
    /** Mean average of tokenId across the matching connection */
    tokenId: Maybe<Scalars['BigFloat']['output']>;
};
type GqlNftBalance = GqlNode & {
    balance: Scalars['BigFloat']['output'];
    id: Scalars['String']['output'];
    /** Reads a single `Nft` that is related to this `NftBalance`. */
    nft: Maybe<GqlNft>;
    nftId: Scalars['String']['output'];
    nftTokenId: Scalars['BigFloat']['output'];
    /** A globally unique identifier. Can be used in various places throughout the system to identify this single value. */
    nodeId: Scalars['ID']['output'];
    /** Reads a single `Wallet` that is related to this `NftBalance`. */
    wallet: Maybe<GqlWallet>;
    walletId: Scalars['String']['output'];
};
type GqlNftBalanceAggregates = {
    /** Mean average aggregates across the matching connection (ignoring before/after/first/last/offset) */
    average: Maybe<GqlNftBalanceAverageAggregates>;
    /** Distinct count aggregates across the matching connection (ignoring before/after/first/last/offset) */
    distinctCount: Maybe<GqlNftBalanceDistinctCountAggregates>;
    keys: Maybe<Array<Scalars['String']['output']>>;
    /** Maximum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    max: Maybe<GqlNftBalanceMaxAggregates>;
    /** Minimum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    min: Maybe<GqlNftBalanceMinAggregates>;
    /** Population standard deviation aggregates across the matching connection (ignoring before/after/first/last/offset) */
    stddevPopulation: Maybe<GqlNftBalanceStddevPopulationAggregates>;
    /** Sample standard deviation aggregates across the matching connection (ignoring before/after/first/last/offset) */
    stddevSample: Maybe<GqlNftBalanceStddevSampleAggregates>;
    /** Sum aggregates across the matching connection (ignoring before/after/first/last/offset) */
    sum: Maybe<GqlNftBalanceSumAggregates>;
    /** Population variance aggregates across the matching connection (ignoring before/after/first/last/offset) */
    variancePopulation: Maybe<GqlNftBalanceVariancePopulationAggregates>;
    /** Sample variance aggregates across the matching connection (ignoring before/after/first/last/offset) */
    varianceSample: Maybe<GqlNftBalanceVarianceSampleAggregates>;
};
/** A filter to be used against aggregates of `NftBalance` object types. */
type GqlNftBalanceAggregatesFilter = {
    /** Mean average aggregate over matching `NftBalance` objects. */
    average?: InputMaybe<GqlNftBalanceAverageAggregateFilter>;
    /** Distinct count aggregate over matching `NftBalance` objects. */
    distinctCount?: InputMaybe<GqlNftBalanceDistinctCountAggregateFilter>;
    /** A filter that must pass for the relevant `NftBalance` object to be included within the aggregate. */
    filter?: InputMaybe<GqlNftBalanceFilter>;
    /** Maximum aggregate over matching `NftBalance` objects. */
    max?: InputMaybe<GqlNftBalanceMaxAggregateFilter>;
    /** Minimum aggregate over matching `NftBalance` objects. */
    min?: InputMaybe<GqlNftBalanceMinAggregateFilter>;
    /** Population standard deviation aggregate over matching `NftBalance` objects. */
    stddevPopulation?: InputMaybe<GqlNftBalanceStddevPopulationAggregateFilter>;
    /** Sample standard deviation aggregate over matching `NftBalance` objects. */
    stddevSample?: InputMaybe<GqlNftBalanceStddevSampleAggregateFilter>;
    /** Sum aggregate over matching `NftBalance` objects. */
    sum?: InputMaybe<GqlNftBalanceSumAggregateFilter>;
    /** Population variance aggregate over matching `NftBalance` objects. */
    variancePopulation?: InputMaybe<GqlNftBalanceVariancePopulationAggregateFilter>;
    /** Sample variance aggregate over matching `NftBalance` objects. */
    varianceSample?: InputMaybe<GqlNftBalanceVarianceSampleAggregateFilter>;
};
type GqlNftBalanceAverageAggregateFilter = {
    balance?: InputMaybe<GqlBigFloatFilter>;
    nftTokenId?: InputMaybe<GqlBigFloatFilter>;
};
type GqlNftBalanceAverageAggregates = {
    /** Mean average of balance across the matching connection */
    balance: Maybe<Scalars['BigFloat']['output']>;
    /** Mean average of nftTokenId across the matching connection */
    nftTokenId: Maybe<Scalars['BigFloat']['output']>;
};
type GqlNftBalanceDistinctCountAggregateFilter = {
    _blockRange?: InputMaybe<GqlBigIntFilter>;
    _id?: InputMaybe<GqlBigIntFilter>;
    balance?: InputMaybe<GqlBigIntFilter>;
    id?: InputMaybe<GqlBigIntFilter>;
    nftId?: InputMaybe<GqlBigIntFilter>;
    nftTokenId?: InputMaybe<GqlBigIntFilter>;
    walletId?: InputMaybe<GqlBigIntFilter>;
};
type GqlNftBalanceDistinctCountAggregates = {
    /** Distinct count of _blockRange across the matching connection */
    _blockRange: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of _id across the matching connection */
    _id: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of balance across the matching connection */
    balance: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of id across the matching connection */
    id: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of nftId across the matching connection */
    nftId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of nftTokenId across the matching connection */
    nftTokenId: Maybe<Scalars['BigInt']['output']>;
    /** Distinct count of walletId across the matching connection */
    walletId: Maybe<Scalars['BigInt']['output']>;
};
/** A filter to be used against `NftBalance` object types. All fields are combined with a logical ‘and.’ */
type GqlNftBalanceFilter = {
    /** Checks for all expressions in this list. */
    and?: InputMaybe<Array<GqlNftBalanceFilter>>;
    /** Filter by the object’s `balance` field. */
    balance?: InputMaybe<GqlBigFloatFilter>;
    /** Filter by the object’s `id` field. */
    id?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `nft` relation. */
    nft?: InputMaybe<GqlNftFilter>;
    /** Filter by the object’s `nftId` field. */
    nftId?: InputMaybe<GqlStringFilter>;
    /** Filter by the object’s `nftTokenId` field. */
    nftTokenId?: InputMaybe<GqlBigFloatFilter>;
    /** Negates the expression. */
    not?: InputMaybe<GqlNftBalanceFilter>;
    /** Checks for any expressions in this list. */
    or?: InputMaybe<Array<GqlNftBalanceFilter>>;
    /** Filter by the object’s `wallet` relation. */
    wallet?: InputMaybe<GqlWalletFilter>;
    /** Filter by the object’s `walletId` field. */
    walletId?: InputMaybe<GqlStringFilter>;
};
type GqlNftBalanceMaxAggregateFilter = {
    balance?: InputMaybe<GqlBigFloatFilter>;
    nftTokenId?: