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;
    };
    bigint: {
        input: any;
        output: any;
    };
    jsonb: {
        input: any;
        output: any;
    };
    numeric: {
        input: any;
        output: any;
    };
    timestamp: {
        input: any;
        output: any;
    };
    timestamptz: {
        input: any;
        output: any;
    };
};
/** Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'. */
type BooleanComparisonExp = {
    _eq?: InputMaybe<Scalars["Boolean"]["input"]>;
    _gt?: InputMaybe<Scalars["Boolean"]["input"]>;
    _gte?: InputMaybe<Scalars["Boolean"]["input"]>;
    _in?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lte?: InputMaybe<Scalars["Boolean"]["input"]>;
    _neq?: InputMaybe<Scalars["Boolean"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
};
/** Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'. */
type IntComparisonExp = {
    _eq?: InputMaybe<Scalars["Int"]["input"]>;
    _gt?: InputMaybe<Scalars["Int"]["input"]>;
    _gte?: InputMaybe<Scalars["Int"]["input"]>;
    _in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["Int"]["input"]>;
    _lte?: InputMaybe<Scalars["Int"]["input"]>;
    _neq?: InputMaybe<Scalars["Int"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["Int"]["input"]>>;
};
/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
type StringComparisonExp = {
    _eq?: InputMaybe<Scalars["String"]["input"]>;
    _gt?: InputMaybe<Scalars["String"]["input"]>;
    _gte?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column match the given case-insensitive pattern */
    _ilike?: InputMaybe<Scalars["String"]["input"]>;
    _in?: InputMaybe<Array<Scalars["String"]["input"]>>;
    /** does the column match the given POSIX regular expression, case insensitive */
    _iregex?: InputMaybe<Scalars["String"]["input"]>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    /** does the column match the given pattern */
    _like?: InputMaybe<Scalars["String"]["input"]>;
    _lt?: InputMaybe<Scalars["String"]["input"]>;
    _lte?: InputMaybe<Scalars["String"]["input"]>;
    _neq?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column NOT match the given case-insensitive pattern */
    _nilike?: InputMaybe<Scalars["String"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["String"]["input"]>>;
    /** does the column NOT match the given POSIX regular expression, case insensitive */
    _niregex?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column NOT match the given pattern */
    _nlike?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column NOT match the given POSIX regular expression, case sensitive */
    _nregex?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column NOT match the given SQL regular expression */
    _nsimilar?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column match the given POSIX regular expression, case sensitive */
    _regex?: InputMaybe<Scalars["String"]["input"]>;
    /** does the column match the given SQL regular expression */
    _similar?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactions = {
    account_address: Scalars["String"]["output"];
    /** An array relationship */
    coin_activities: Array<CoinActivities>;
    /** An aggregate relationship */
    coin_activities_aggregate: CoinActivitiesAggregate;
    /** An array relationship */
    delegated_staking_activities: Array<DelegatedStakingActivities>;
    /** An array relationship */
    fungible_asset_activities: Array<FungibleAssetActivities>;
    /** An array relationship */
    token_activities: Array<TokenActivities>;
    /** An aggregate relationship */
    token_activities_aggregate: TokenActivitiesAggregate;
    /** An array relationship */
    token_activities_v2: Array<TokenActivitiesV2>;
    /** An aggregate relationship */
    token_activities_v2_aggregate: TokenActivitiesV2Aggregate;
    transaction_version: Scalars["bigint"]["output"];
    /** An object relationship */
    user_transaction?: Maybe<UserTransactions>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsCoinActivitiesArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsCoinActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsDelegatedStakingActivitiesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingActivitiesOrderBy>>;
    where?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsFungibleAssetActivitiesArgs = {
    distinct_on?: InputMaybe<Array<FungibleAssetActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<FungibleAssetActivitiesOrderBy>>;
    where?: InputMaybe<FungibleAssetActivitiesBoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsTokenActivitiesArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsTokenActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsTokenActivitiesV2Args = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
/** columns and relationships of "account_transactions" */
type AccountTransactionsTokenActivitiesV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
/** aggregated selection of "account_transactions" */
type AccountTransactionsAggregate = {
    aggregate?: Maybe<AccountTransactionsAggregateFields>;
    nodes: Array<AccountTransactions>;
};
/** aggregate fields of "account_transactions" */
type AccountTransactionsAggregateFields = {
    avg?: Maybe<AccountTransactionsAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<AccountTransactionsMaxFields>;
    min?: Maybe<AccountTransactionsMinFields>;
    stddev?: Maybe<AccountTransactionsStddevFields>;
    stddev_pop?: Maybe<AccountTransactionsStddevPopFields>;
    stddev_samp?: Maybe<AccountTransactionsStddevSampFields>;
    sum?: Maybe<AccountTransactionsSumFields>;
    var_pop?: Maybe<AccountTransactionsVarPopFields>;
    var_samp?: Maybe<AccountTransactionsVarSampFields>;
    variance?: Maybe<AccountTransactionsVarianceFields>;
};
/** aggregate fields of "account_transactions" */
type AccountTransactionsAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<AccountTransactionsSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type AccountTransactionsAvgFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "account_transactions". All fields are combined with a logical 'AND'. */
type AccountTransactionsBoolExp = {
    _and?: InputMaybe<Array<AccountTransactionsBoolExp>>;
    _not?: InputMaybe<AccountTransactionsBoolExp>;
    _or?: InputMaybe<Array<AccountTransactionsBoolExp>>;
    account_address?: InputMaybe<StringComparisonExp>;
    coin_activities?: InputMaybe<CoinActivitiesBoolExp>;
    coin_activities_aggregate?: InputMaybe<CoinActivitiesAggregateBoolExp>;
    delegated_staking_activities?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
    fungible_asset_activities?: InputMaybe<FungibleAssetActivitiesBoolExp>;
    token_activities?: InputMaybe<TokenActivitiesBoolExp>;
    token_activities_aggregate?: InputMaybe<TokenActivitiesAggregateBoolExp>;
    token_activities_v2?: InputMaybe<TokenActivitiesV2BoolExp>;
    token_activities_v2_aggregate?: InputMaybe<TokenActivitiesV2AggregateBoolExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    user_transaction?: InputMaybe<UserTransactionsBoolExp>;
};
/** aggregate max on columns */
type AccountTransactionsMaxFields = {
    account_address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate min on columns */
type AccountTransactionsMinFields = {
    account_address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** Ordering options when selecting data from "account_transactions". */
type AccountTransactionsOrderBy = {
    account_address?: InputMaybe<OrderBy>;
    coin_activities_aggregate?: InputMaybe<CoinActivitiesAggregateOrderBy>;
    delegated_staking_activities_aggregate?: InputMaybe<DelegatedStakingActivitiesAggregateOrderBy>;
    fungible_asset_activities_aggregate?: InputMaybe<FungibleAssetActivitiesAggregateOrderBy>;
    token_activities_aggregate?: InputMaybe<TokenActivitiesAggregateOrderBy>;
    token_activities_v2_aggregate?: InputMaybe<TokenActivitiesV2AggregateOrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    user_transaction?: InputMaybe<UserTransactionsOrderBy>;
};
/** select columns of table "account_transactions" */
declare enum AccountTransactionsSelectColumn {
    /** column name */
    AccountAddress = "account_address",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** aggregate stddev on columns */
type AccountTransactionsStddevFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type AccountTransactionsStddevPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type AccountTransactionsStddevSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "account_transactions" */
type AccountTransactionsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: AccountTransactionsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type AccountTransactionsStreamCursorValueInput = {
    account_address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** aggregate sum on columns */
type AccountTransactionsSumFields = {
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type AccountTransactionsVarPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type AccountTransactionsVarSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type AccountTransactionsVarianceFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "address_events_summary" */
type AddressEventsSummary = {
    account_address?: Maybe<Scalars["String"]["output"]>;
    /** An object relationship */
    block_metadata?: Maybe<BlockMetadataTransactions>;
    min_block_height?: Maybe<Scalars["bigint"]["output"]>;
    num_distinct_versions?: Maybe<Scalars["bigint"]["output"]>;
};
/** Boolean expression to filter rows from the table "address_events_summary". All fields are combined with a logical 'AND'. */
type AddressEventsSummaryBoolExp = {
    _and?: InputMaybe<Array<AddressEventsSummaryBoolExp>>;
    _not?: InputMaybe<AddressEventsSummaryBoolExp>;
    _or?: InputMaybe<Array<AddressEventsSummaryBoolExp>>;
    account_address?: InputMaybe<StringComparisonExp>;
    block_metadata?: InputMaybe<BlockMetadataTransactionsBoolExp>;
    min_block_height?: InputMaybe<BigintComparisonExp>;
    num_distinct_versions?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "address_events_summary". */
type AddressEventsSummaryOrderBy = {
    account_address?: InputMaybe<OrderBy>;
    block_metadata?: InputMaybe<BlockMetadataTransactionsOrderBy>;
    min_block_height?: InputMaybe<OrderBy>;
    num_distinct_versions?: InputMaybe<OrderBy>;
};
/** select columns of table "address_events_summary" */
declare enum AddressEventsSummarySelectColumn {
    /** column name */
    AccountAddress = "account_address",
    /** column name */
    MinBlockHeight = "min_block_height",
    /** column name */
    NumDistinctVersions = "num_distinct_versions"
}
/** Streaming cursor of the table "address_events_summary" */
type AddressEventsSummaryStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: AddressEventsSummaryStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type AddressEventsSummaryStreamCursorValueInput = {
    account_address?: InputMaybe<Scalars["String"]["input"]>;
    min_block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    num_distinct_versions?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEvents = {
    account_address?: Maybe<Scalars["String"]["output"]>;
    /** An array relationship */
    coin_activities: Array<CoinActivities>;
    /** An aggregate relationship */
    coin_activities_aggregate: CoinActivitiesAggregate;
    /** An array relationship */
    delegated_staking_activities: Array<DelegatedStakingActivities>;
    /** An array relationship */
    token_activities: Array<TokenActivities>;
    /** An aggregate relationship */
    token_activities_aggregate: TokenActivitiesAggregate;
    /** An array relationship */
    token_activities_v2: Array<TokenActivitiesV2>;
    /** An aggregate relationship */
    token_activities_v2_aggregate: TokenActivitiesV2Aggregate;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsCoinActivitiesArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsCoinActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsDelegatedStakingActivitiesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingActivitiesOrderBy>>;
    where?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsTokenActivitiesArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsTokenActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsTokenActivitiesV2Args = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
/** columns and relationships of "address_version_from_events" */
type AddressVersionFromEventsTokenActivitiesV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
/** aggregated selection of "address_version_from_events" */
type AddressVersionFromEventsAggregate = {
    aggregate?: Maybe<AddressVersionFromEventsAggregateFields>;
    nodes: Array<AddressVersionFromEvents>;
};
/** aggregate fields of "address_version_from_events" */
type AddressVersionFromEventsAggregateFields = {
    avg?: Maybe<AddressVersionFromEventsAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<AddressVersionFromEventsMaxFields>;
    min?: Maybe<AddressVersionFromEventsMinFields>;
    stddev?: Maybe<AddressVersionFromEventsStddevFields>;
    stddev_pop?: Maybe<AddressVersionFromEventsStddevPopFields>;
    stddev_samp?: Maybe<AddressVersionFromEventsStddevSampFields>;
    sum?: Maybe<AddressVersionFromEventsSumFields>;
    var_pop?: Maybe<AddressVersionFromEventsVarPopFields>;
    var_samp?: Maybe<AddressVersionFromEventsVarSampFields>;
    variance?: Maybe<AddressVersionFromEventsVarianceFields>;
};
/** aggregate fields of "address_version_from_events" */
type AddressVersionFromEventsAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<AddressVersionFromEventsSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type AddressVersionFromEventsAvgFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "address_version_from_events". All fields are combined with a logical 'AND'. */
type AddressVersionFromEventsBoolExp = {
    _and?: InputMaybe<Array<AddressVersionFromEventsBoolExp>>;
    _not?: InputMaybe<AddressVersionFromEventsBoolExp>;
    _or?: InputMaybe<Array<AddressVersionFromEventsBoolExp>>;
    account_address?: InputMaybe<StringComparisonExp>;
    coin_activities?: InputMaybe<CoinActivitiesBoolExp>;
    coin_activities_aggregate?: InputMaybe<CoinActivitiesAggregateBoolExp>;
    delegated_staking_activities?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
    token_activities?: InputMaybe<TokenActivitiesBoolExp>;
    token_activities_aggregate?: InputMaybe<TokenActivitiesAggregateBoolExp>;
    token_activities_v2?: InputMaybe<TokenActivitiesV2BoolExp>;
    token_activities_v2_aggregate?: InputMaybe<TokenActivitiesV2AggregateBoolExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** aggregate max on columns */
type AddressVersionFromEventsMaxFields = {
    account_address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate min on columns */
type AddressVersionFromEventsMinFields = {
    account_address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** Ordering options when selecting data from "address_version_from_events". */
type AddressVersionFromEventsOrderBy = {
    account_address?: InputMaybe<OrderBy>;
    coin_activities_aggregate?: InputMaybe<CoinActivitiesAggregateOrderBy>;
    delegated_staking_activities_aggregate?: InputMaybe<DelegatedStakingActivitiesAggregateOrderBy>;
    token_activities_aggregate?: InputMaybe<TokenActivitiesAggregateOrderBy>;
    token_activities_v2_aggregate?: InputMaybe<TokenActivitiesV2AggregateOrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "address_version_from_events" */
declare enum AddressVersionFromEventsSelectColumn {
    /** column name */
    AccountAddress = "account_address",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** aggregate stddev on columns */
type AddressVersionFromEventsStddevFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type AddressVersionFromEventsStddevPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type AddressVersionFromEventsStddevSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "address_version_from_events" */
type AddressVersionFromEventsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: AddressVersionFromEventsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type AddressVersionFromEventsStreamCursorValueInput = {
    account_address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** aggregate sum on columns */
type AddressVersionFromEventsSumFields = {
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type AddressVersionFromEventsVarPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type AddressVersionFromEventsVarSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type AddressVersionFromEventsVarianceFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResources = {
    address?: Maybe<Scalars["String"]["output"]>;
    /** An array relationship */
    coin_activities: Array<CoinActivities>;
    /** An aggregate relationship */
    coin_activities_aggregate: CoinActivitiesAggregate;
    /** An array relationship */
    delegated_staking_activities: Array<DelegatedStakingActivities>;
    /** An array relationship */
    token_activities: Array<TokenActivities>;
    /** An aggregate relationship */
    token_activities_aggregate: TokenActivitiesAggregate;
    /** An array relationship */
    token_activities_v2: Array<TokenActivitiesV2>;
    /** An aggregate relationship */
    token_activities_v2_aggregate: TokenActivitiesV2Aggregate;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesCoinActivitiesArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesCoinActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesDelegatedStakingActivitiesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingActivitiesOrderBy>>;
    where?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesTokenActivitiesArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesTokenActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesTokenActivitiesV2Args = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
/** columns and relationships of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesTokenActivitiesV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
/** aggregated selection of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesAggregate = {
    aggregate?: Maybe<AddressVersionFromMoveResourcesAggregateFields>;
    nodes: Array<AddressVersionFromMoveResources>;
};
/** aggregate fields of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesAggregateFields = {
    avg?: Maybe<AddressVersionFromMoveResourcesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<AddressVersionFromMoveResourcesMaxFields>;
    min?: Maybe<AddressVersionFromMoveResourcesMinFields>;
    stddev?: Maybe<AddressVersionFromMoveResourcesStddevFields>;
    stddev_pop?: Maybe<AddressVersionFromMoveResourcesStddevPopFields>;
    stddev_samp?: Maybe<AddressVersionFromMoveResourcesStddevSampFields>;
    sum?: Maybe<AddressVersionFromMoveResourcesSumFields>;
    var_pop?: Maybe<AddressVersionFromMoveResourcesVarPopFields>;
    var_samp?: Maybe<AddressVersionFromMoveResourcesVarSampFields>;
    variance?: Maybe<AddressVersionFromMoveResourcesVarianceFields>;
};
/** aggregate fields of "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<AddressVersionFromMoveResourcesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type AddressVersionFromMoveResourcesAvgFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "address_version_from_move_resources". All fields are combined with a logical 'AND'. */
type AddressVersionFromMoveResourcesBoolExp = {
    _and?: InputMaybe<Array<AddressVersionFromMoveResourcesBoolExp>>;
    _not?: InputMaybe<AddressVersionFromMoveResourcesBoolExp>;
    _or?: InputMaybe<Array<AddressVersionFromMoveResourcesBoolExp>>;
    address?: InputMaybe<StringComparisonExp>;
    coin_activities?: InputMaybe<CoinActivitiesBoolExp>;
    coin_activities_aggregate?: InputMaybe<CoinActivitiesAggregateBoolExp>;
    delegated_staking_activities?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
    token_activities?: InputMaybe<TokenActivitiesBoolExp>;
    token_activities_aggregate?: InputMaybe<TokenActivitiesAggregateBoolExp>;
    token_activities_v2?: InputMaybe<TokenActivitiesV2BoolExp>;
    token_activities_v2_aggregate?: InputMaybe<TokenActivitiesV2AggregateBoolExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** aggregate max on columns */
type AddressVersionFromMoveResourcesMaxFields = {
    address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate min on columns */
type AddressVersionFromMoveResourcesMinFields = {
    address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** Ordering options when selecting data from "address_version_from_move_resources". */
type AddressVersionFromMoveResourcesOrderBy = {
    address?: InputMaybe<OrderBy>;
    coin_activities_aggregate?: InputMaybe<CoinActivitiesAggregateOrderBy>;
    delegated_staking_activities_aggregate?: InputMaybe<DelegatedStakingActivitiesAggregateOrderBy>;
    token_activities_aggregate?: InputMaybe<TokenActivitiesAggregateOrderBy>;
    token_activities_v2_aggregate?: InputMaybe<TokenActivitiesV2AggregateOrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "address_version_from_move_resources" */
declare enum AddressVersionFromMoveResourcesSelectColumn {
    /** column name */
    Address = "address",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** aggregate stddev on columns */
type AddressVersionFromMoveResourcesStddevFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type AddressVersionFromMoveResourcesStddevPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type AddressVersionFromMoveResourcesStddevSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "address_version_from_move_resources" */
type AddressVersionFromMoveResourcesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: AddressVersionFromMoveResourcesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type AddressVersionFromMoveResourcesStreamCursorValueInput = {
    address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** aggregate sum on columns */
type AddressVersionFromMoveResourcesSumFields = {
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type AddressVersionFromMoveResourcesVarPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type AddressVersionFromMoveResourcesVarSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type AddressVersionFromMoveResourcesVarianceFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'. */
type BigintComparisonExp = {
    _eq?: InputMaybe<Scalars["bigint"]["input"]>;
    _gt?: InputMaybe<Scalars["bigint"]["input"]>;
    _gte?: InputMaybe<Scalars["bigint"]["input"]>;
    _in?: InputMaybe<Array<Scalars["bigint"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["bigint"]["input"]>;
    _lte?: InputMaybe<Scalars["bigint"]["input"]>;
    _neq?: InputMaybe<Scalars["bigint"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["bigint"]["input"]>>;
};
/** columns and relationships of "block_metadata_transactions" */
type BlockMetadataTransactions = {
    block_height: Scalars["bigint"]["output"];
    epoch: Scalars["bigint"]["output"];
    failed_proposer_indices: Scalars["jsonb"]["output"];
    id: Scalars["String"]["output"];
    previous_block_votes_bitvec: Scalars["jsonb"]["output"];
    proposer: Scalars["String"]["output"];
    round: Scalars["bigint"]["output"];
    timestamp: Scalars["timestamp"]["output"];
    version: Scalars["bigint"]["output"];
};
/** columns and relationships of "block_metadata_transactions" */
type BlockMetadataTransactionsFailedProposerIndicesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "block_metadata_transactions" */
type BlockMetadataTransactionsPreviousBlockVotesBitvecArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "block_metadata_transactions". All fields are combined with a logical 'AND'. */
type BlockMetadataTransactionsBoolExp = {
    _and?: InputMaybe<Array<BlockMetadataTransactionsBoolExp>>;
    _not?: InputMaybe<BlockMetadataTransactionsBoolExp>;
    _or?: InputMaybe<Array<BlockMetadataTransactionsBoolExp>>;
    block_height?: InputMaybe<BigintComparisonExp>;
    epoch?: InputMaybe<BigintComparisonExp>;
    failed_proposer_indices?: InputMaybe<JsonbComparisonExp>;
    id?: InputMaybe<StringComparisonExp>;
    previous_block_votes_bitvec?: InputMaybe<JsonbComparisonExp>;
    proposer?: InputMaybe<StringComparisonExp>;
    round?: InputMaybe<BigintComparisonExp>;
    timestamp?: InputMaybe<TimestampComparisonExp>;
    version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "block_metadata_transactions". */
type BlockMetadataTransactionsOrderBy = {
    block_height?: InputMaybe<OrderBy>;
    epoch?: InputMaybe<OrderBy>;
    failed_proposer_indices?: InputMaybe<OrderBy>;
    id?: InputMaybe<OrderBy>;
    previous_block_votes_bitvec?: InputMaybe<OrderBy>;
    proposer?: InputMaybe<OrderBy>;
    round?: InputMaybe<OrderBy>;
    timestamp?: InputMaybe<OrderBy>;
    version?: InputMaybe<OrderBy>;
};
/** select columns of table "block_metadata_transactions" */
declare enum BlockMetadataTransactionsSelectColumn {
    /** column name */
    BlockHeight = "block_height",
    /** column name */
    Epoch = "epoch",
    /** column name */
    FailedProposerIndices = "failed_proposer_indices",
    /** column name */
    Id = "id",
    /** column name */
    PreviousBlockVotesBitvec = "previous_block_votes_bitvec",
    /** column name */
    Proposer = "proposer",
    /** column name */
    Round = "round",
    /** column name */
    Timestamp = "timestamp",
    /** column name */
    Version = "version"
}
/** Streaming cursor of the table "block_metadata_transactions" */
type BlockMetadataTransactionsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: BlockMetadataTransactionsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type BlockMetadataTransactionsStreamCursorValueInput = {
    block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    epoch?: InputMaybe<Scalars["bigint"]["input"]>;
    failed_proposer_indices?: InputMaybe<Scalars["jsonb"]["input"]>;
    id?: InputMaybe<Scalars["String"]["input"]>;
    previous_block_votes_bitvec?: InputMaybe<Scalars["jsonb"]["input"]>;
    proposer?: InputMaybe<Scalars["String"]["input"]>;
    round?: InputMaybe<Scalars["bigint"]["input"]>;
    timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "coin_activities" */
type CoinActivities = {
    activity_type: Scalars["String"]["output"];
    amount: Scalars["numeric"]["output"];
    /** An array relationship */
    aptos_names: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    aptos_names_aggregate: CurrentAptosNamesAggregate;
    block_height: Scalars["bigint"]["output"];
    /** An object relationship */
    coin_info?: Maybe<CoinInfos>;
    coin_type: Scalars["String"]["output"];
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_account_address: Scalars["String"]["output"];
    event_creation_number: Scalars["bigint"]["output"];
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number: Scalars["bigint"]["output"];
    is_gas_fee: Scalars["Boolean"]["output"];
    is_transaction_success: Scalars["Boolean"]["output"];
    owner_address: Scalars["String"]["output"];
    storage_refund_amount: Scalars["numeric"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** columns and relationships of "coin_activities" */
type CoinActivitiesAptosNamesArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "coin_activities" */
type CoinActivitiesAptosNamesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** aggregated selection of "coin_activities" */
type CoinActivitiesAggregate = {
    aggregate?: Maybe<CoinActivitiesAggregateFields>;
    nodes: Array<CoinActivities>;
};
type CoinActivitiesAggregateBoolExp = {
    bool_and?: InputMaybe<CoinActivitiesAggregateBoolExpBoolAnd>;
    bool_or?: InputMaybe<CoinActivitiesAggregateBoolExpBoolOr>;
    count?: InputMaybe<CoinActivitiesAggregateBoolExpCount>;
};
type CoinActivitiesAggregateBoolExpBoolAnd = {
    arguments: CoinActivitiesSelectColumnCoinActivitiesAggregateBoolExpBoolAndArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CoinActivitiesBoolExp>;
    predicate: BooleanComparisonExp;
};
type CoinActivitiesAggregateBoolExpBoolOr = {
    arguments: CoinActivitiesSelectColumnCoinActivitiesAggregateBoolExpBoolOrArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CoinActivitiesBoolExp>;
    predicate: BooleanComparisonExp;
};
type CoinActivitiesAggregateBoolExpCount = {
    arguments?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CoinActivitiesBoolExp>;
    predicate: IntComparisonExp;
};
/** aggregate fields of "coin_activities" */
type CoinActivitiesAggregateFields = {
    avg?: Maybe<CoinActivitiesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<CoinActivitiesMaxFields>;
    min?: Maybe<CoinActivitiesMinFields>;
    stddev?: Maybe<CoinActivitiesStddevFields>;
    stddev_pop?: Maybe<CoinActivitiesStddevPopFields>;
    stddev_samp?: Maybe<CoinActivitiesStddevSampFields>;
    sum?: Maybe<CoinActivitiesSumFields>;
    var_pop?: Maybe<CoinActivitiesVarPopFields>;
    var_samp?: Maybe<CoinActivitiesVarSampFields>;
    variance?: Maybe<CoinActivitiesVarianceFields>;
};
/** aggregate fields of "coin_activities" */
type CoinActivitiesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** order by aggregate values of table "coin_activities" */
type CoinActivitiesAggregateOrderBy = {
    avg?: InputMaybe<CoinActivitiesAvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<CoinActivitiesMaxOrderBy>;
    min?: InputMaybe<CoinActivitiesMinOrderBy>;
    stddev?: InputMaybe<CoinActivitiesStddevOrderBy>;
    stddev_pop?: InputMaybe<CoinActivitiesStddevPopOrderBy>;
    stddev_samp?: InputMaybe<CoinActivitiesStddevSampOrderBy>;
    sum?: InputMaybe<CoinActivitiesSumOrderBy>;
    var_pop?: InputMaybe<CoinActivitiesVarPopOrderBy>;
    var_samp?: InputMaybe<CoinActivitiesVarSampOrderBy>;
    variance?: InputMaybe<CoinActivitiesVarianceOrderBy>;
};
/** aggregate avg on columns */
type CoinActivitiesAvgFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by avg() on columns of table "coin_activities" */
type CoinActivitiesAvgOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "coin_activities". All fields are combined with a logical 'AND'. */
type CoinActivitiesBoolExp = {
    _and?: InputMaybe<Array<CoinActivitiesBoolExp>>;
    _not?: InputMaybe<CoinActivitiesBoolExp>;
    _or?: InputMaybe<Array<CoinActivitiesBoolExp>>;
    activity_type?: InputMaybe<StringComparisonExp>;
    amount?: InputMaybe<NumericComparisonExp>;
    aptos_names?: InputMaybe<CurrentAptosNamesBoolExp>;
    aptos_names_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    block_height?: InputMaybe<BigintComparisonExp>;
    coin_info?: InputMaybe<CoinInfosBoolExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    event_account_address?: InputMaybe<StringComparisonExp>;
    event_creation_number?: InputMaybe<BigintComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    event_sequence_number?: InputMaybe<BigintComparisonExp>;
    is_gas_fee?: InputMaybe<BooleanComparisonExp>;
    is_transaction_success?: InputMaybe<BooleanComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    storage_refund_amount?: InputMaybe<NumericComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** aggregate max on columns */
type CoinActivitiesMaxFields = {
    activity_type?: Maybe<Scalars["String"]["output"]>;
    amount?: Maybe<Scalars["numeric"]["output"]>;
    block_height?: Maybe<Scalars["bigint"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_account_address?: Maybe<Scalars["String"]["output"]>;
    event_creation_number?: Maybe<Scalars["bigint"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["numeric"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** order by max() on columns of table "coin_activities" */
type CoinActivitiesMaxOrderBy = {
    activity_type?: InputMaybe<OrderBy>;
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate min on columns */
type CoinActivitiesMinFields = {
    activity_type?: Maybe<Scalars["String"]["output"]>;
    amount?: Maybe<Scalars["numeric"]["output"]>;
    block_height?: Maybe<Scalars["bigint"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_account_address?: Maybe<Scalars["String"]["output"]>;
    event_creation_number?: Maybe<Scalars["bigint"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["numeric"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** order by min() on columns of table "coin_activities" */
type CoinActivitiesMinOrderBy = {
    activity_type?: InputMaybe<OrderBy>;
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "coin_activities". */
type CoinActivitiesOrderBy = {
    activity_type?: InputMaybe<OrderBy>;
    amount?: InputMaybe<OrderBy>;
    aptos_names_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    block_height?: InputMaybe<OrderBy>;
    coin_info?: InputMaybe<CoinInfosOrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    is_gas_fee?: InputMaybe<OrderBy>;
    is_transaction_success?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "coin_activities" */
declare enum CoinActivitiesSelectColumn {
    /** column name */
    ActivityType = "activity_type",
    /** column name */
    Amount = "amount",
    /** column name */
    BlockHeight = "block_height",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    EventAccountAddress = "event_account_address",
    /** column name */
    EventCreationNumber = "event_creation_number",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    EventSequenceNumber = "event_sequence_number",
    /** column name */
    IsGasFee = "is_gas_fee",
    /** column name */
    IsTransactionSuccess = "is_transaction_success",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    StorageRefundAmount = "storage_refund_amount",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** select "coin_activities_aggregate_bool_exp_bool_and_arguments_columns" columns of table "coin_activities" */
declare enum CoinActivitiesSelectColumnCoinActivitiesAggregateBoolExpBoolAndArgumentsColumns {
    /** column name */
    IsGasFee = "is_gas_fee",
    /** column name */
    IsTransactionSuccess = "is_transaction_success"
}
/** select "coin_activities_aggregate_bool_exp_bool_or_arguments_columns" columns of table "coin_activities" */
declare enum CoinActivitiesSelectColumnCoinActivitiesAggregateBoolExpBoolOrArgumentsColumns {
    /** column name */
    IsGasFee = "is_gas_fee",
    /** column name */
    IsTransactionSuccess = "is_transaction_success"
}
/** aggregate stddev on columns */
type CoinActivitiesStddevFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev() on columns of table "coin_activities" */
type CoinActivitiesStddevOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_pop on columns */
type CoinActivitiesStddevPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_pop() on columns of table "coin_activities" */
type CoinActivitiesStddevPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_samp on columns */
type CoinActivitiesStddevSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_samp() on columns of table "coin_activities" */
type CoinActivitiesStddevSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "coin_activities" */
type CoinActivitiesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CoinActivitiesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CoinActivitiesStreamCursorValueInput = {
    activity_type?: InputMaybe<Scalars["String"]["input"]>;
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    event_account_address?: InputMaybe<Scalars["String"]["input"]>;
    event_creation_number?: InputMaybe<Scalars["bigint"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    event_sequence_number?: InputMaybe<Scalars["bigint"]["input"]>;
    is_gas_fee?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_transaction_success?: InputMaybe<Scalars["Boolean"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    storage_refund_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** aggregate sum on columns */
type CoinActivitiesSumFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    block_height?: Maybe<Scalars["bigint"]["output"]>;
    event_creation_number?: Maybe<Scalars["bigint"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number?: Maybe<Scalars["bigint"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["numeric"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** order by sum() on columns of table "coin_activities" */
type CoinActivitiesSumOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate var_pop on columns */
type CoinActivitiesVarPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_pop() on columns of table "coin_activities" */
type CoinActivitiesVarPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate var_samp on columns */
type CoinActivitiesVarSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_samp() on columns of table "coin_activities" */
type CoinActivitiesVarSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate variance on columns */
type CoinActivitiesVarianceFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    block_height?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    storage_refund_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by variance() on columns of table "coin_activities" */
type CoinActivitiesVarianceOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "coin_balances" */
type CoinBalances = {
    amount: Scalars["numeric"]["output"];
    coin_type: Scalars["String"]["output"];
    coin_type_hash: Scalars["String"]["output"];
    owner_address: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "coin_balances". All fields are combined with a logical 'AND'. */
type CoinBalancesBoolExp = {
    _and?: InputMaybe<Array<CoinBalancesBoolExp>>;
    _not?: InputMaybe<CoinBalancesBoolExp>;
    _or?: InputMaybe<Array<CoinBalancesBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    coin_type_hash?: InputMaybe<StringComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "coin_balances". */
type CoinBalancesOrderBy = {
    amount?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    coin_type_hash?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "coin_balances" */
declare enum CoinBalancesSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CoinTypeHash = "coin_type_hash",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** Streaming cursor of the table "coin_balances" */
type CoinBalancesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CoinBalancesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CoinBalancesStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    coin_type_hash?: InputMaybe<Scalars["String"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "coin_infos" */
type CoinInfos = {
    coin_type: Scalars["String"]["output"];
    coin_type_hash: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    decimals: Scalars["Int"]["output"];
    name: Scalars["String"]["output"];
    supply_aggregator_table_handle?: Maybe<Scalars["String"]["output"]>;
    supply_aggregator_table_key?: Maybe<Scalars["String"]["output"]>;
    symbol: Scalars["String"]["output"];
    transaction_created_timestamp: Scalars["timestamp"]["output"];
    transaction_version_created: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "coin_infos". All fields are combined with a logical 'AND'. */
type CoinInfosBoolExp = {
    _and?: InputMaybe<Array<CoinInfosBoolExp>>;
    _not?: InputMaybe<CoinInfosBoolExp>;
    _or?: InputMaybe<Array<CoinInfosBoolExp>>;
    coin_type?: InputMaybe<StringComparisonExp>;
    coin_type_hash?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    decimals?: InputMaybe<IntComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    supply_aggregator_table_handle?: InputMaybe<StringComparisonExp>;
    supply_aggregator_table_key?: InputMaybe<StringComparisonExp>;
    symbol?: InputMaybe<StringComparisonExp>;
    transaction_created_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version_created?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "coin_infos". */
type CoinInfosOrderBy = {
    coin_type?: InputMaybe<OrderBy>;
    coin_type_hash?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    decimals?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    supply_aggregator_table_handle?: InputMaybe<OrderBy>;
    supply_aggregator_table_key?: InputMaybe<OrderBy>;
    symbol?: InputMaybe<OrderBy>;
    transaction_created_timestamp?: InputMaybe<OrderBy>;
    transaction_version_created?: InputMaybe<OrderBy>;
};
/** select columns of table "coin_infos" */
declare enum CoinInfosSelectColumn {
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CoinTypeHash = "coin_type_hash",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    Decimals = "decimals",
    /** column name */
    Name = "name",
    /** column name */
    SupplyAggregatorTableHandle = "supply_aggregator_table_handle",
    /** column name */
    SupplyAggregatorTableKey = "supply_aggregator_table_key",
    /** column name */
    Symbol = "symbol",
    /** column name */
    TransactionCreatedTimestamp = "transaction_created_timestamp",
    /** column name */
    TransactionVersionCreated = "transaction_version_created"
}
/** Streaming cursor of the table "coin_infos" */
type CoinInfosStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CoinInfosStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CoinInfosStreamCursorValueInput = {
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    coin_type_hash?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    decimals?: InputMaybe<Scalars["Int"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    supply_aggregator_table_handle?: InputMaybe<Scalars["String"]["input"]>;
    supply_aggregator_table_key?: InputMaybe<Scalars["String"]["input"]>;
    symbol?: InputMaybe<Scalars["String"]["input"]>;
    transaction_created_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version_created?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "coin_supply" */
type CoinSupply = {
    coin_type: Scalars["String"]["output"];
    coin_type_hash: Scalars["String"]["output"];
    supply: Scalars["numeric"]["output"];
    transaction_epoch: Scalars["bigint"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "coin_supply". All fields are combined with a logical 'AND'. */
type CoinSupplyBoolExp = {
    _and?: InputMaybe<Array<CoinSupplyBoolExp>>;
    _not?: InputMaybe<CoinSupplyBoolExp>;
    _or?: InputMaybe<Array<CoinSupplyBoolExp>>;
    coin_type?: InputMaybe<StringComparisonExp>;
    coin_type_hash?: InputMaybe<StringComparisonExp>;
    supply?: InputMaybe<NumericComparisonExp>;
    transaction_epoch?: InputMaybe<BigintComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "coin_supply". */
type CoinSupplyOrderBy = {
    coin_type?: InputMaybe<OrderBy>;
    coin_type_hash?: InputMaybe<OrderBy>;
    supply?: InputMaybe<OrderBy>;
    transaction_epoch?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "coin_supply" */
declare enum CoinSupplySelectColumn {
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CoinTypeHash = "coin_type_hash",
    /** column name */
    Supply = "supply",
    /** column name */
    TransactionEpoch = "transaction_epoch",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** Streaming cursor of the table "coin_supply" */
type CoinSupplyStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CoinSupplyStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CoinSupplyStreamCursorValueInput = {
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    coin_type_hash?: InputMaybe<Scalars["String"]["input"]>;
    supply?: InputMaybe<Scalars["numeric"]["input"]>;
    transaction_epoch?: InputMaybe<Scalars["bigint"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "collection_datas" */
type CollectionDatas = {
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    description: Scalars["String"]["output"];
    description_mutable: Scalars["Boolean"]["output"];
    maximum: Scalars["numeric"]["output"];
    maximum_mutable: Scalars["Boolean"]["output"];
    metadata_uri: Scalars["String"]["output"];
    supply: Scalars["numeric"]["output"];
    table_handle: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    uri_mutable: Scalars["Boolean"]["output"];
};
/** Boolean expression to filter rows from the table "collection_datas". All fields are combined with a logical 'AND'. */
type CollectionDatasBoolExp = {
    _and?: InputMaybe<Array<CollectionDatasBoolExp>>;
    _not?: InputMaybe<CollectionDatasBoolExp>;
    _or?: InputMaybe<Array<CollectionDatasBoolExp>>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    description?: InputMaybe<StringComparisonExp>;
    description_mutable?: InputMaybe<BooleanComparisonExp>;
    maximum?: InputMaybe<NumericComparisonExp>;
    maximum_mutable?: InputMaybe<BooleanComparisonExp>;
    metadata_uri?: InputMaybe<StringComparisonExp>;
    supply?: InputMaybe<NumericComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    uri_mutable?: InputMaybe<BooleanComparisonExp>;
};
/** Ordering options when selecting data from "collection_datas". */
type CollectionDatasOrderBy = {
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    description?: InputMaybe<OrderBy>;
    description_mutable?: InputMaybe<OrderBy>;
    maximum?: InputMaybe<OrderBy>;
    maximum_mutable?: InputMaybe<OrderBy>;
    metadata_uri?: InputMaybe<OrderBy>;
    supply?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    uri_mutable?: InputMaybe<OrderBy>;
};
/** select columns of table "collection_datas" */
declare enum CollectionDatasSelectColumn {
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    Description = "description",
    /** column name */
    DescriptionMutable = "description_mutable",
    /** column name */
    Maximum = "maximum",
    /** column name */
    MaximumMutable = "maximum_mutable",
    /** column name */
    MetadataUri = "metadata_uri",
    /** column name */
    Supply = "supply",
    /** column name */
    TableHandle = "table_handle",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    UriMutable = "uri_mutable"
}
/** Streaming cursor of the table "collection_datas" */
type CollectionDatasStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CollectionDatasStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CollectionDatasStreamCursorValueInput = {
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    description?: InputMaybe<Scalars["String"]["input"]>;
    description_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    maximum?: InputMaybe<Scalars["numeric"]["input"]>;
    maximum_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    metadata_uri?: InputMaybe<Scalars["String"]["input"]>;
    supply?: InputMaybe<Scalars["numeric"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    uri_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** columns and relationships of "current_ans_lookup" */
type CurrentAnsLookup = {
    /** An array relationship */
    all_token_ownerships: Array<CurrentTokenOwnerships>;
    /** An aggregate relationship */
    all_token_ownerships_aggregate: CurrentTokenOwnershipsAggregate;
    domain: Scalars["String"]["output"];
    expiration_timestamp: Scalars["timestamp"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    registered_address?: Maybe<Scalars["String"]["output"]>;
    subdomain: Scalars["String"]["output"];
    token_name: Scalars["String"]["output"];
};
/** columns and relationships of "current_ans_lookup" */
type CurrentAnsLookupAllTokenOwnershipsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsOrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
/** columns and relationships of "current_ans_lookup" */
type CurrentAnsLookupAllTokenOwnershipsAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsOrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
/** Boolean expression to filter rows from the table "current_ans_lookup". All fields are combined with a logical 'AND'. */
type CurrentAnsLookupBoolExp = {
    _and?: InputMaybe<Array<CurrentAnsLookupBoolExp>>;
    _not?: InputMaybe<CurrentAnsLookupBoolExp>;
    _or?: InputMaybe<Array<CurrentAnsLookupBoolExp>>;
    all_token_ownerships?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
    all_token_ownerships_aggregate?: InputMaybe<CurrentTokenOwnershipsAggregateBoolExp>;
    domain?: InputMaybe<StringComparisonExp>;
    expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    registered_address?: InputMaybe<StringComparisonExp>;
    subdomain?: InputMaybe<StringComparisonExp>;
    token_name?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_ans_lookup". */
type CurrentAnsLookupOrderBy = {
    all_token_ownerships_aggregate?: InputMaybe<CurrentTokenOwnershipsAggregateOrderBy>;
    domain?: InputMaybe<OrderBy>;
    expiration_timestamp?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    registered_address?: InputMaybe<OrderBy>;
    subdomain?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
};
/** select columns of table "current_ans_lookup" */
declare enum CurrentAnsLookupSelectColumn {
    /** column name */
    Domain = "domain",
    /** column name */
    ExpirationTimestamp = "expiration_timestamp",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    RegisteredAddress = "registered_address",
    /** column name */
    Subdomain = "subdomain",
    /** column name */
    TokenName = "token_name"
}
/** Streaming cursor of the table "current_ans_lookup" */
type CurrentAnsLookupStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentAnsLookupStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentAnsLookupStreamCursorValueInput = {
    domain?: InputMaybe<Scalars["String"]["input"]>;
    expiration_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    registered_address?: InputMaybe<Scalars["String"]["input"]>;
    subdomain?: InputMaybe<Scalars["String"]["input"]>;
    token_name?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_ans_lookup_v2" */
type CurrentAnsLookupV2 = {
    domain: Scalars["String"]["output"];
    expiration_timestamp: Scalars["timestamp"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    registered_address?: Maybe<Scalars["String"]["output"]>;
    subdomain: Scalars["String"]["output"];
    token_name?: Maybe<Scalars["String"]["output"]>;
    token_standard: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "current_ans_lookup_v2". All fields are combined with a logical 'AND'. */
type CurrentAnsLookupV2BoolExp = {
    _and?: InputMaybe<Array<CurrentAnsLookupV2BoolExp>>;
    _not?: InputMaybe<CurrentAnsLookupV2BoolExp>;
    _or?: InputMaybe<Array<CurrentAnsLookupV2BoolExp>>;
    domain?: InputMaybe<StringComparisonExp>;
    expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    registered_address?: InputMaybe<StringComparisonExp>;
    subdomain?: InputMaybe<StringComparisonExp>;
    token_name?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_ans_lookup_v2". */
type CurrentAnsLookupV2OrderBy = {
    domain?: InputMaybe<OrderBy>;
    expiration_timestamp?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    registered_address?: InputMaybe<OrderBy>;
    subdomain?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "current_ans_lookup_v2" */
declare enum CurrentAnsLookupV2SelectColumn {
    /** column name */
    Domain = "domain",
    /** column name */
    ExpirationTimestamp = "expiration_timestamp",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    RegisteredAddress = "registered_address",
    /** column name */
    Subdomain = "subdomain",
    /** column name */
    TokenName = "token_name",
    /** column name */
    TokenStandard = "token_standard"
}
/** Streaming cursor of the table "current_ans_lookup_v2" */
type CurrentAnsLookupV2StreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentAnsLookupV2StreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentAnsLookupV2StreamCursorValueInput = {
    domain?: InputMaybe<Scalars["String"]["input"]>;
    expiration_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    registered_address?: InputMaybe<Scalars["String"]["input"]>;
    subdomain?: InputMaybe<Scalars["String"]["input"]>;
    token_name?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_aptos_names" */
type CurrentAptosNames = {
    domain?: Maybe<Scalars["String"]["output"]>;
    domain_expiration_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    domain_with_suffix?: Maybe<Scalars["String"]["output"]>;
    expiration_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    is_active?: Maybe<Scalars["Boolean"]["output"]>;
    /** An object relationship */
    is_domain_owner?: Maybe<CurrentAptosNames>;
    is_primary?: Maybe<Scalars["Boolean"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    registered_address?: Maybe<Scalars["String"]["output"]>;
    subdomain?: Maybe<Scalars["String"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["bigint"]["output"]>;
    token_name?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** aggregated selection of "current_aptos_names" */
type CurrentAptosNamesAggregate = {
    aggregate?: Maybe<CurrentAptosNamesAggregateFields>;
    nodes: Array<CurrentAptosNames>;
};
type CurrentAptosNamesAggregateBoolExp = {
    bool_and?: InputMaybe<CurrentAptosNamesAggregateBoolExpBoolAnd>;
    bool_or?: InputMaybe<CurrentAptosNamesAggregateBoolExpBoolOr>;
    count?: InputMaybe<CurrentAptosNamesAggregateBoolExpCount>;
};
type CurrentAptosNamesAggregateBoolExpBoolAnd = {
    arguments: CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolAndArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentAptosNamesBoolExp>;
    predicate: BooleanComparisonExp;
};
type CurrentAptosNamesAggregateBoolExpBoolOr = {
    arguments: CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolOrArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentAptosNamesBoolExp>;
    predicate: BooleanComparisonExp;
};
type CurrentAptosNamesAggregateBoolExpCount = {
    arguments?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentAptosNamesBoolExp>;
    predicate: IntComparisonExp;
};
/** aggregate fields of "current_aptos_names" */
type CurrentAptosNamesAggregateFields = {
    avg?: Maybe<CurrentAptosNamesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<CurrentAptosNamesMaxFields>;
    min?: Maybe<CurrentAptosNamesMinFields>;
    stddev?: Maybe<CurrentAptosNamesStddevFields>;
    stddev_pop?: Maybe<CurrentAptosNamesStddevPopFields>;
    stddev_samp?: Maybe<CurrentAptosNamesStddevSampFields>;
    sum?: Maybe<CurrentAptosNamesSumFields>;
    var_pop?: Maybe<CurrentAptosNamesVarPopFields>;
    var_samp?: Maybe<CurrentAptosNamesVarSampFields>;
    variance?: Maybe<CurrentAptosNamesVarianceFields>;
};
/** aggregate fields of "current_aptos_names" */
type CurrentAptosNamesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** order by aggregate values of table "current_aptos_names" */
type CurrentAptosNamesAggregateOrderBy = {
    avg?: InputMaybe<CurrentAptosNamesAvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<CurrentAptosNamesMaxOrderBy>;
    min?: InputMaybe<CurrentAptosNamesMinOrderBy>;
    stddev?: InputMaybe<CurrentAptosNamesStddevOrderBy>;
    stddev_pop?: InputMaybe<CurrentAptosNamesStddevPopOrderBy>;
    stddev_samp?: InputMaybe<CurrentAptosNamesStddevSampOrderBy>;
    sum?: InputMaybe<CurrentAptosNamesSumOrderBy>;
    var_pop?: InputMaybe<CurrentAptosNamesVarPopOrderBy>;
    var_samp?: InputMaybe<CurrentAptosNamesVarSampOrderBy>;
    variance?: InputMaybe<CurrentAptosNamesVarianceOrderBy>;
};
/** aggregate avg on columns */
type CurrentAptosNamesAvgFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by avg() on columns of table "current_aptos_names" */
type CurrentAptosNamesAvgOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "current_aptos_names". All fields are combined with a logical 'AND'. */
type CurrentAptosNamesBoolExp = {
    _and?: InputMaybe<Array<CurrentAptosNamesBoolExp>>;
    _not?: InputMaybe<CurrentAptosNamesBoolExp>;
    _or?: InputMaybe<Array<CurrentAptosNamesBoolExp>>;
    domain?: InputMaybe<StringComparisonExp>;
    domain_expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
    domain_with_suffix?: InputMaybe<StringComparisonExp>;
    expiration_timestamp?: InputMaybe<TimestampComparisonExp>;
    is_active?: InputMaybe<BooleanComparisonExp>;
    is_domain_owner?: InputMaybe<CurrentAptosNamesBoolExp>;
    is_primary?: InputMaybe<BooleanComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    registered_address?: InputMaybe<StringComparisonExp>;
    subdomain?: InputMaybe<StringComparisonExp>;
    subdomain_expiration_policy?: InputMaybe<BigintComparisonExp>;
    token_name?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type CurrentAptosNamesMaxFields = {
    domain?: Maybe<Scalars["String"]["output"]>;
    domain_expiration_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    domain_with_suffix?: Maybe<Scalars["String"]["output"]>;
    expiration_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    registered_address?: Maybe<Scalars["String"]["output"]>;
    subdomain?: Maybe<Scalars["String"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["bigint"]["output"]>;
    token_name?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** order by max() on columns of table "current_aptos_names" */
type CurrentAptosNamesMaxOrderBy = {
    domain?: InputMaybe<OrderBy>;
    domain_expiration_timestamp?: InputMaybe<OrderBy>;
    domain_with_suffix?: InputMaybe<OrderBy>;
    expiration_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    registered_address?: InputMaybe<OrderBy>;
    subdomain?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** aggregate min on columns */
type CurrentAptosNamesMinFields = {
    domain?: Maybe<Scalars["String"]["output"]>;
    domain_expiration_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    domain_with_suffix?: Maybe<Scalars["String"]["output"]>;
    expiration_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    registered_address?: Maybe<Scalars["String"]["output"]>;
    subdomain?: Maybe<Scalars["String"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["bigint"]["output"]>;
    token_name?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** order by min() on columns of table "current_aptos_names" */
type CurrentAptosNamesMinOrderBy = {
    domain?: InputMaybe<OrderBy>;
    domain_expiration_timestamp?: InputMaybe<OrderBy>;
    domain_with_suffix?: InputMaybe<OrderBy>;
    expiration_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    registered_address?: InputMaybe<OrderBy>;
    subdomain?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "current_aptos_names". */
type CurrentAptosNamesOrderBy = {
    domain?: InputMaybe<OrderBy>;
    domain_expiration_timestamp?: InputMaybe<OrderBy>;
    domain_with_suffix?: InputMaybe<OrderBy>;
    expiration_timestamp?: InputMaybe<OrderBy>;
    is_active?: InputMaybe<OrderBy>;
    is_domain_owner?: InputMaybe<CurrentAptosNamesOrderBy>;
    is_primary?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    registered_address?: InputMaybe<OrderBy>;
    subdomain?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "current_aptos_names" */
declare enum CurrentAptosNamesSelectColumn {
    /** column name */
    Domain = "domain",
    /** column name */
    DomainExpirationTimestamp = "domain_expiration_timestamp",
    /** column name */
    DomainWithSuffix = "domain_with_suffix",
    /** column name */
    ExpirationTimestamp = "expiration_timestamp",
    /** column name */
    IsActive = "is_active",
    /** column name */
    IsPrimary = "is_primary",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    RegisteredAddress = "registered_address",
    /** column name */
    Subdomain = "subdomain",
    /** column name */
    SubdomainExpirationPolicy = "subdomain_expiration_policy",
    /** column name */
    TokenName = "token_name",
    /** column name */
    TokenStandard = "token_standard"
}
/** select "current_aptos_names_aggregate_bool_exp_bool_and_arguments_columns" columns of table "current_aptos_names" */
declare enum CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolAndArgumentsColumns {
    /** column name */
    IsActive = "is_active",
    /** column name */
    IsPrimary = "is_primary"
}
/** select "current_aptos_names_aggregate_bool_exp_bool_or_arguments_columns" columns of table "current_aptos_names" */
declare enum CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolOrArgumentsColumns {
    /** column name */
    IsActive = "is_active",
    /** column name */
    IsPrimary = "is_primary"
}
/** aggregate stddev on columns */
type CurrentAptosNamesStddevFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev() on columns of table "current_aptos_names" */
type CurrentAptosNamesStddevOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** aggregate stddev_pop on columns */
type CurrentAptosNamesStddevPopFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_pop() on columns of table "current_aptos_names" */
type CurrentAptosNamesStddevPopOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** aggregate stddev_samp on columns */
type CurrentAptosNamesStddevSampFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_samp() on columns of table "current_aptos_names" */
type CurrentAptosNamesStddevSampOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "current_aptos_names" */
type CurrentAptosNamesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentAptosNamesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentAptosNamesStreamCursorValueInput = {
    domain?: InputMaybe<Scalars["String"]["input"]>;
    domain_expiration_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    domain_with_suffix?: InputMaybe<Scalars["String"]["input"]>;
    expiration_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    is_active?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    registered_address?: InputMaybe<Scalars["String"]["input"]>;
    subdomain?: InputMaybe<Scalars["String"]["input"]>;
    subdomain_expiration_policy?: InputMaybe<Scalars["bigint"]["input"]>;
    token_name?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type CurrentAptosNamesSumFields = {
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["bigint"]["output"]>;
};
/** order by sum() on columns of table "current_aptos_names" */
type CurrentAptosNamesSumOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** aggregate var_pop on columns */
type CurrentAptosNamesVarPopFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_pop() on columns of table "current_aptos_names" */
type CurrentAptosNamesVarPopOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** aggregate var_samp on columns */
type CurrentAptosNamesVarSampFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_samp() on columns of table "current_aptos_names" */
type CurrentAptosNamesVarSampOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** aggregate variance on columns */
type CurrentAptosNamesVarianceFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    subdomain_expiration_policy?: Maybe<Scalars["Float"]["output"]>;
};
/** order by variance() on columns of table "current_aptos_names" */
type CurrentAptosNamesVarianceOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    subdomain_expiration_policy?: InputMaybe<OrderBy>;
};
/** columns and relationships of "current_coin_balances" */
type CurrentCoinBalances = {
    amount: Scalars["numeric"]["output"];
    /** An object relationship */
    coin_info?: Maybe<CoinInfos>;
    coin_type: Scalars["String"]["output"];
    coin_type_hash: Scalars["String"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    owner_address: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "current_coin_balances". All fields are combined with a logical 'AND'. */
type CurrentCoinBalancesBoolExp = {
    _and?: InputMaybe<Array<CurrentCoinBalancesBoolExp>>;
    _not?: InputMaybe<CurrentCoinBalancesBoolExp>;
    _or?: InputMaybe<Array<CurrentCoinBalancesBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    coin_info?: InputMaybe<CoinInfosBoolExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    coin_type_hash?: InputMaybe<StringComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_coin_balances". */
type CurrentCoinBalancesOrderBy = {
    amount?: InputMaybe<OrderBy>;
    coin_info?: InputMaybe<CoinInfosOrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    coin_type_hash?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
};
/** select columns of table "current_coin_balances" */
declare enum CurrentCoinBalancesSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CoinTypeHash = "coin_type_hash",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    OwnerAddress = "owner_address"
}
/** Streaming cursor of the table "current_coin_balances" */
type CurrentCoinBalancesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentCoinBalancesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentCoinBalancesStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    coin_type_hash?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_collection_datas" */
type CurrentCollectionDatas = {
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    description: Scalars["String"]["output"];
    description_mutable: Scalars["Boolean"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    maximum: Scalars["numeric"]["output"];
    maximum_mutable: Scalars["Boolean"]["output"];
    metadata_uri: Scalars["String"]["output"];
    supply: Scalars["numeric"]["output"];
    table_handle: Scalars["String"]["output"];
    uri_mutable: Scalars["Boolean"]["output"];
};
/** Boolean expression to filter rows from the table "current_collection_datas". All fields are combined with a logical 'AND'. */
type CurrentCollectionDatasBoolExp = {
    _and?: InputMaybe<Array<CurrentCollectionDatasBoolExp>>;
    _not?: InputMaybe<CurrentCollectionDatasBoolExp>;
    _or?: InputMaybe<Array<CurrentCollectionDatasBoolExp>>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    description?: InputMaybe<StringComparisonExp>;
    description_mutable?: InputMaybe<BooleanComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    maximum?: InputMaybe<NumericComparisonExp>;
    maximum_mutable?: InputMaybe<BooleanComparisonExp>;
    metadata_uri?: InputMaybe<StringComparisonExp>;
    supply?: InputMaybe<NumericComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
    uri_mutable?: InputMaybe<BooleanComparisonExp>;
};
/** Ordering options when selecting data from "current_collection_datas". */
type CurrentCollectionDatasOrderBy = {
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    description?: InputMaybe<OrderBy>;
    description_mutable?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    maximum?: InputMaybe<OrderBy>;
    maximum_mutable?: InputMaybe<OrderBy>;
    metadata_uri?: InputMaybe<OrderBy>;
    supply?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
    uri_mutable?: InputMaybe<OrderBy>;
};
/** select columns of table "current_collection_datas" */
declare enum CurrentCollectionDatasSelectColumn {
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    Description = "description",
    /** column name */
    DescriptionMutable = "description_mutable",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Maximum = "maximum",
    /** column name */
    MaximumMutable = "maximum_mutable",
    /** column name */
    MetadataUri = "metadata_uri",
    /** column name */
    Supply = "supply",
    /** column name */
    TableHandle = "table_handle",
    /** column name */
    UriMutable = "uri_mutable"
}
/** Streaming cursor of the table "current_collection_datas" */
type CurrentCollectionDatasStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentCollectionDatasStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentCollectionDatasStreamCursorValueInput = {
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    description?: InputMaybe<Scalars["String"]["input"]>;
    description_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    maximum?: InputMaybe<Scalars["numeric"]["input"]>;
    maximum_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    metadata_uri?: InputMaybe<Scalars["String"]["input"]>;
    supply?: InputMaybe<Scalars["numeric"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
    uri_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** columns and relationships of "current_collection_ownership_v2_view" */
type CurrentCollectionOwnershipV2View = {
    collection_id?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    collection_uri?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    /** An object relationship */
    current_collection?: Maybe<CurrentCollectionsV2>;
    distinct_tokens?: Maybe<Scalars["bigint"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    single_token_uri?: Maybe<Scalars["String"]["output"]>;
};
/** aggregated selection of "current_collection_ownership_v2_view" */
type CurrentCollectionOwnershipV2ViewAggregate = {
    aggregate?: Maybe<CurrentCollectionOwnershipV2ViewAggregateFields>;
    nodes: Array<CurrentCollectionOwnershipV2View>;
};
/** aggregate fields of "current_collection_ownership_v2_view" */
type CurrentCollectionOwnershipV2ViewAggregateFields = {
    avg?: Maybe<CurrentCollectionOwnershipV2ViewAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<CurrentCollectionOwnershipV2ViewMaxFields>;
    min?: Maybe<CurrentCollectionOwnershipV2ViewMinFields>;
    stddev?: Maybe<CurrentCollectionOwnershipV2ViewStddevFields>;
    stddev_pop?: Maybe<CurrentCollectionOwnershipV2ViewStddevPopFields>;
    stddev_samp?: Maybe<CurrentCollectionOwnershipV2ViewStddevSampFields>;
    sum?: Maybe<CurrentCollectionOwnershipV2ViewSumFields>;
    var_pop?: Maybe<CurrentCollectionOwnershipV2ViewVarPopFields>;
    var_samp?: Maybe<CurrentCollectionOwnershipV2ViewVarSampFields>;
    variance?: Maybe<CurrentCollectionOwnershipV2ViewVarianceFields>;
};
/** aggregate fields of "current_collection_ownership_v2_view" */
type CurrentCollectionOwnershipV2ViewAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type CurrentCollectionOwnershipV2ViewAvgFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "current_collection_ownership_v2_view". All fields are combined with a logical 'AND'. */
type CurrentCollectionOwnershipV2ViewBoolExp = {
    _and?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewBoolExp>>;
    _not?: InputMaybe<CurrentCollectionOwnershipV2ViewBoolExp>;
    _or?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewBoolExp>>;
    collection_id?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    collection_uri?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_collection?: InputMaybe<CurrentCollectionsV2BoolExp>;
    distinct_tokens?: InputMaybe<BigintComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    single_token_uri?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type CurrentCollectionOwnershipV2ViewMaxFields = {
    collection_id?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    collection_uri?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    distinct_tokens?: Maybe<Scalars["bigint"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    single_token_uri?: Maybe<Scalars["String"]["output"]>;
};
/** aggregate min on columns */
type CurrentCollectionOwnershipV2ViewMinFields = {
    collection_id?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    collection_uri?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    distinct_tokens?: Maybe<Scalars["bigint"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    single_token_uri?: Maybe<Scalars["String"]["output"]>;
};
/** Ordering options when selecting data from "current_collection_ownership_v2_view". */
type CurrentCollectionOwnershipV2ViewOrderBy = {
    collection_id?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    collection_uri?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_collection?: InputMaybe<CurrentCollectionsV2OrderBy>;
    distinct_tokens?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    single_token_uri?: InputMaybe<OrderBy>;
};
/** select columns of table "current_collection_ownership_v2_view" */
declare enum CurrentCollectionOwnershipV2ViewSelectColumn {
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CollectionUri = "collection_uri",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    DistinctTokens = "distinct_tokens",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    SingleTokenUri = "single_token_uri"
}
/** aggregate stddev on columns */
type CurrentCollectionOwnershipV2ViewStddevFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type CurrentCollectionOwnershipV2ViewStddevPopFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type CurrentCollectionOwnershipV2ViewStddevSampFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "current_collection_ownership_v2_view" */
type CurrentCollectionOwnershipV2ViewStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentCollectionOwnershipV2ViewStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentCollectionOwnershipV2ViewStreamCursorValueInput = {
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    collection_uri?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    distinct_tokens?: InputMaybe<Scalars["bigint"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    single_token_uri?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type CurrentCollectionOwnershipV2ViewSumFields = {
    distinct_tokens?: Maybe<Scalars["bigint"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type CurrentCollectionOwnershipV2ViewVarPopFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type CurrentCollectionOwnershipV2ViewVarSampFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type CurrentCollectionOwnershipV2ViewVarianceFields = {
    distinct_tokens?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "current_collections_v2" */
type CurrentCollectionsV2 = {
    /** An object relationship */
    cdn_asset_uris?: Maybe<NftMetadataCrawlerParsedAssetUris>;
    collection_id: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    current_supply: Scalars["numeric"]["output"];
    description: Scalars["String"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    max_supply?: Maybe<Scalars["numeric"]["output"]>;
    mutable_description?: Maybe<Scalars["Boolean"]["output"]>;
    mutable_uri?: Maybe<Scalars["Boolean"]["output"]>;
    table_handle_v1?: Maybe<Scalars["String"]["output"]>;
    token_standard: Scalars["String"]["output"];
    total_minted_v2?: Maybe<Scalars["numeric"]["output"]>;
    uri: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "current_collections_v2". All fields are combined with a logical 'AND'. */
type CurrentCollectionsV2BoolExp = {
    _and?: InputMaybe<Array<CurrentCollectionsV2BoolExp>>;
    _not?: InputMaybe<CurrentCollectionsV2BoolExp>;
    _or?: InputMaybe<Array<CurrentCollectionsV2BoolExp>>;
    cdn_asset_uris?: InputMaybe<NftMetadataCrawlerParsedAssetUrisBoolExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_supply?: InputMaybe<NumericComparisonExp>;
    description?: InputMaybe<StringComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    max_supply?: InputMaybe<NumericComparisonExp>;
    mutable_description?: InputMaybe<BooleanComparisonExp>;
    mutable_uri?: InputMaybe<BooleanComparisonExp>;
    table_handle_v1?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
    total_minted_v2?: InputMaybe<NumericComparisonExp>;
    uri?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_collections_v2". */
type CurrentCollectionsV2OrderBy = {
    cdn_asset_uris?: InputMaybe<NftMetadataCrawlerParsedAssetUrisOrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_supply?: InputMaybe<OrderBy>;
    description?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    max_supply?: InputMaybe<OrderBy>;
    mutable_description?: InputMaybe<OrderBy>;
    mutable_uri?: InputMaybe<OrderBy>;
    table_handle_v1?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    total_minted_v2?: InputMaybe<OrderBy>;
    uri?: InputMaybe<OrderBy>;
};
/** select columns of table "current_collections_v2" */
declare enum CurrentCollectionsV2SelectColumn {
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    CurrentSupply = "current_supply",
    /** column name */
    Description = "description",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    MaxSupply = "max_supply",
    /** column name */
    MutableDescription = "mutable_description",
    /** column name */
    MutableUri = "mutable_uri",
    /** column name */
    TableHandleV1 = "table_handle_v1",
    /** column name */
    TokenStandard = "token_standard",
    /** column name */
    TotalMintedV2 = "total_minted_v2",
    /** column name */
    Uri = "uri"
}
/** Streaming cursor of the table "current_collections_v2" */
type CurrentCollectionsV2StreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentCollectionsV2StreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentCollectionsV2StreamCursorValueInput = {
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    current_supply?: InputMaybe<Scalars["numeric"]["input"]>;
    description?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    max_supply?: InputMaybe<Scalars["numeric"]["input"]>;
    mutable_description?: InputMaybe<Scalars["Boolean"]["input"]>;
    mutable_uri?: InputMaybe<Scalars["Boolean"]["input"]>;
    table_handle_v1?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
    total_minted_v2?: InputMaybe<Scalars["numeric"]["input"]>;
    uri?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_delegated_staking_pool_balances" */
type CurrentDelegatedStakingPoolBalances = {
    active_table_handle: Scalars["String"]["output"];
    inactive_table_handle: Scalars["String"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    operator_commission_percentage: Scalars["numeric"]["output"];
    staking_pool_address: Scalars["String"]["output"];
    total_coins: Scalars["numeric"]["output"];
    total_shares: Scalars["numeric"]["output"];
};
/** Boolean expression to filter rows from the table "current_delegated_staking_pool_balances". All fields are combined with a logical 'AND'. */
type CurrentDelegatedStakingPoolBalancesBoolExp = {
    _and?: InputMaybe<Array<CurrentDelegatedStakingPoolBalancesBoolExp>>;
    _not?: InputMaybe<CurrentDelegatedStakingPoolBalancesBoolExp>;
    _or?: InputMaybe<Array<CurrentDelegatedStakingPoolBalancesBoolExp>>;
    active_table_handle?: InputMaybe<StringComparisonExp>;
    inactive_table_handle?: InputMaybe<StringComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    operator_commission_percentage?: InputMaybe<NumericComparisonExp>;
    staking_pool_address?: InputMaybe<StringComparisonExp>;
    total_coins?: InputMaybe<NumericComparisonExp>;
    total_shares?: InputMaybe<NumericComparisonExp>;
};
/** Ordering options when selecting data from "current_delegated_staking_pool_balances". */
type CurrentDelegatedStakingPoolBalancesOrderBy = {
    active_table_handle?: InputMaybe<OrderBy>;
    inactive_table_handle?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    operator_commission_percentage?: InputMaybe<OrderBy>;
    staking_pool_address?: InputMaybe<OrderBy>;
    total_coins?: InputMaybe<OrderBy>;
    total_shares?: InputMaybe<OrderBy>;
};
/** select columns of table "current_delegated_staking_pool_balances" */
declare enum CurrentDelegatedStakingPoolBalancesSelectColumn {
    /** column name */
    ActiveTableHandle = "active_table_handle",
    /** column name */
    InactiveTableHandle = "inactive_table_handle",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    OperatorCommissionPercentage = "operator_commission_percentage",
    /** column name */
    StakingPoolAddress = "staking_pool_address",
    /** column name */
    TotalCoins = "total_coins",
    /** column name */
    TotalShares = "total_shares"
}
/** Streaming cursor of the table "current_delegated_staking_pool_balances" */
type CurrentDelegatedStakingPoolBalancesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentDelegatedStakingPoolBalancesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentDelegatedStakingPoolBalancesStreamCursorValueInput = {
    active_table_handle?: InputMaybe<Scalars["String"]["input"]>;
    inactive_table_handle?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    operator_commission_percentage?: InputMaybe<Scalars["numeric"]["input"]>;
    staking_pool_address?: InputMaybe<Scalars["String"]["input"]>;
    total_coins?: InputMaybe<Scalars["numeric"]["input"]>;
    total_shares?: InputMaybe<Scalars["numeric"]["input"]>;
};
/** columns and relationships of "current_delegated_voter" */
type CurrentDelegatedVoter = {
    delegation_pool_address: Scalars["String"]["output"];
    delegator_address: Scalars["String"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    pending_voter?: Maybe<Scalars["String"]["output"]>;
    table_handle?: Maybe<Scalars["String"]["output"]>;
    voter?: Maybe<Scalars["String"]["output"]>;
};
/** Boolean expression to filter rows from the table "current_delegated_voter". All fields are combined with a logical 'AND'. */
type CurrentDelegatedVoterBoolExp = {
    _and?: InputMaybe<Array<CurrentDelegatedVoterBoolExp>>;
    _not?: InputMaybe<CurrentDelegatedVoterBoolExp>;
    _or?: InputMaybe<Array<CurrentDelegatedVoterBoolExp>>;
    delegation_pool_address?: InputMaybe<StringComparisonExp>;
    delegator_address?: InputMaybe<StringComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    pending_voter?: InputMaybe<StringComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
    voter?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_delegated_voter". */
type CurrentDelegatedVoterOrderBy = {
    delegation_pool_address?: InputMaybe<OrderBy>;
    delegator_address?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    pending_voter?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
    voter?: InputMaybe<OrderBy>;
};
/** select columns of table "current_delegated_voter" */
declare enum CurrentDelegatedVoterSelectColumn {
    /** column name */
    DelegationPoolAddress = "delegation_pool_address",
    /** column name */
    DelegatorAddress = "delegator_address",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    PendingVoter = "pending_voter",
    /** column name */
    TableHandle = "table_handle",
    /** column name */
    Voter = "voter"
}
/** Streaming cursor of the table "current_delegated_voter" */
type CurrentDelegatedVoterStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentDelegatedVoterStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentDelegatedVoterStreamCursorValueInput = {
    delegation_pool_address?: InputMaybe<Scalars["String"]["input"]>;
    delegator_address?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    pending_voter?: InputMaybe<Scalars["String"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
    voter?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_delegator_balances" */
type CurrentDelegatorBalances = {
    /** An object relationship */
    current_pool_balance?: Maybe<CurrentDelegatedStakingPoolBalances>;
    delegator_address: Scalars["String"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    parent_table_handle: Scalars["String"]["output"];
    pool_address: Scalars["String"]["output"];
    pool_type: Scalars["String"]["output"];
    shares: Scalars["numeric"]["output"];
    /** An object relationship */
    staking_pool_metadata?: Maybe<CurrentStakingPoolVoter>;
    table_handle: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "current_delegator_balances". All fields are combined with a logical 'AND'. */
type CurrentDelegatorBalancesBoolExp = {
    _and?: InputMaybe<Array<CurrentDelegatorBalancesBoolExp>>;
    _not?: InputMaybe<CurrentDelegatorBalancesBoolExp>;
    _or?: InputMaybe<Array<CurrentDelegatorBalancesBoolExp>>;
    current_pool_balance?: InputMaybe<CurrentDelegatedStakingPoolBalancesBoolExp>;
    delegator_address?: InputMaybe<StringComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    parent_table_handle?: InputMaybe<StringComparisonExp>;
    pool_address?: InputMaybe<StringComparisonExp>;
    pool_type?: InputMaybe<StringComparisonExp>;
    shares?: InputMaybe<NumericComparisonExp>;
    staking_pool_metadata?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_delegator_balances". */
type CurrentDelegatorBalancesOrderBy = {
    current_pool_balance?: InputMaybe<CurrentDelegatedStakingPoolBalancesOrderBy>;
    delegator_address?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    parent_table_handle?: InputMaybe<OrderBy>;
    pool_address?: InputMaybe<OrderBy>;
    pool_type?: InputMaybe<OrderBy>;
    shares?: InputMaybe<OrderBy>;
    staking_pool_metadata?: InputMaybe<CurrentStakingPoolVoterOrderBy>;
    table_handle?: InputMaybe<OrderBy>;
};
/** select columns of table "current_delegator_balances" */
declare enum CurrentDelegatorBalancesSelectColumn {
    /** column name */
    DelegatorAddress = "delegator_address",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    ParentTableHandle = "parent_table_handle",
    /** column name */
    PoolAddress = "pool_address",
    /** column name */
    PoolType = "pool_type",
    /** column name */
    Shares = "shares",
    /** column name */
    TableHandle = "table_handle"
}
/** Streaming cursor of the table "current_delegator_balances" */
type CurrentDelegatorBalancesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentDelegatorBalancesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentDelegatorBalancesStreamCursorValueInput = {
    delegator_address?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    parent_table_handle?: InputMaybe<Scalars["String"]["input"]>;
    pool_address?: InputMaybe<Scalars["String"]["input"]>;
    pool_type?: InputMaybe<Scalars["String"]["input"]>;
    shares?: InputMaybe<Scalars["numeric"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_fungible_asset_balances" */
type CurrentFungibleAssetBalances = {
    amount: Scalars["numeric"]["output"];
    asset_type: Scalars["String"]["output"];
    is_frozen: Scalars["Boolean"]["output"];
    is_primary: Scalars["Boolean"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    /** An object relationship */
    metadata?: Maybe<FungibleAssetMetadata>;
    owner_address: Scalars["String"]["output"];
    storage_id: Scalars["String"]["output"];
    token_standard: Scalars["String"]["output"];
};
/** aggregated selection of "current_fungible_asset_balances" */
type CurrentFungibleAssetBalancesAggregate = {
    aggregate?: Maybe<CurrentFungibleAssetBalancesAggregateFields>;
    nodes: Array<CurrentFungibleAssetBalances>;
};
/** aggregate fields of "current_fungible_asset_balances" */
type CurrentFungibleAssetBalancesAggregateFields = {
    avg?: Maybe<CurrentFungibleAssetBalancesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<CurrentFungibleAssetBalancesMaxFields>;
    min?: Maybe<CurrentFungibleAssetBalancesMinFields>;
    stddev?: Maybe<CurrentFungibleAssetBalancesStddevFields>;
    stddev_pop?: Maybe<CurrentFungibleAssetBalancesStddevPopFields>;
    stddev_samp?: Maybe<CurrentFungibleAssetBalancesStddevSampFields>;
    sum?: Maybe<CurrentFungibleAssetBalancesSumFields>;
    var_pop?: Maybe<CurrentFungibleAssetBalancesVarPopFields>;
    var_samp?: Maybe<CurrentFungibleAssetBalancesVarSampFields>;
    variance?: Maybe<CurrentFungibleAssetBalancesVarianceFields>;
};
/** aggregate fields of "current_fungible_asset_balances" */
type CurrentFungibleAssetBalancesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<CurrentFungibleAssetBalancesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type CurrentFungibleAssetBalancesAvgFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "current_fungible_asset_balances". All fields are combined with a logical 'AND'. */
type CurrentFungibleAssetBalancesBoolExp = {
    _and?: InputMaybe<Array<CurrentFungibleAssetBalancesBoolExp>>;
    _not?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
    _or?: InputMaybe<Array<CurrentFungibleAssetBalancesBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    asset_type?: InputMaybe<StringComparisonExp>;
    is_frozen?: InputMaybe<BooleanComparisonExp>;
    is_primary?: InputMaybe<BooleanComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    metadata?: InputMaybe<FungibleAssetMetadataBoolExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    storage_id?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type CurrentFungibleAssetBalancesMaxFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    asset_type?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    storage_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** aggregate min on columns */
type CurrentFungibleAssetBalancesMinFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    asset_type?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    storage_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** Ordering options when selecting data from "current_fungible_asset_balances". */
type CurrentFungibleAssetBalancesOrderBy = {
    amount?: InputMaybe<OrderBy>;
    asset_type?: InputMaybe<OrderBy>;
    is_frozen?: InputMaybe<OrderBy>;
    is_primary?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    metadata?: InputMaybe<FungibleAssetMetadataOrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "current_fungible_asset_balances" */
declare enum CurrentFungibleAssetBalancesSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    AssetType = "asset_type",
    /** column name */
    IsFrozen = "is_frozen",
    /** column name */
    IsPrimary = "is_primary",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    StorageId = "storage_id",
    /** column name */
    TokenStandard = "token_standard"
}
/** aggregate stddev on columns */
type CurrentFungibleAssetBalancesStddevFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type CurrentFungibleAssetBalancesStddevPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type CurrentFungibleAssetBalancesStddevSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "current_fungible_asset_balances" */
type CurrentFungibleAssetBalancesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentFungibleAssetBalancesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentFungibleAssetBalancesStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    asset_type?: InputMaybe<Scalars["String"]["input"]>;
    is_frozen?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    storage_id?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type CurrentFungibleAssetBalancesSumFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type CurrentFungibleAssetBalancesVarPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type CurrentFungibleAssetBalancesVarSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type CurrentFungibleAssetBalancesVarianceFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "current_objects" */
type CurrentObjects = {
    allow_ungated_transfer: Scalars["Boolean"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    last_guid_creation_num: Scalars["numeric"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    object_address: Scalars["String"]["output"];
    owner_address: Scalars["String"]["output"];
    state_key_hash: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "current_objects". All fields are combined with a logical 'AND'. */
type CurrentObjectsBoolExp = {
    _and?: InputMaybe<Array<CurrentObjectsBoolExp>>;
    _not?: InputMaybe<CurrentObjectsBoolExp>;
    _or?: InputMaybe<Array<CurrentObjectsBoolExp>>;
    allow_ungated_transfer?: InputMaybe<BooleanComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    last_guid_creation_num?: InputMaybe<NumericComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    object_address?: InputMaybe<StringComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    state_key_hash?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_objects". */
type CurrentObjectsOrderBy = {
    allow_ungated_transfer?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    last_guid_creation_num?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    object_address?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    state_key_hash?: InputMaybe<OrderBy>;
};
/** select columns of table "current_objects" */
declare enum CurrentObjectsSelectColumn {
    /** column name */
    AllowUngatedTransfer = "allow_ungated_transfer",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    LastGuidCreationNum = "last_guid_creation_num",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    ObjectAddress = "object_address",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    StateKeyHash = "state_key_hash"
}
/** Streaming cursor of the table "current_objects" */
type CurrentObjectsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentObjectsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentObjectsStreamCursorValueInput = {
    allow_ungated_transfer?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_guid_creation_num?: InputMaybe<Scalars["numeric"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    object_address?: InputMaybe<Scalars["String"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    state_key_hash?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_staking_pool_voter" */
type CurrentStakingPoolVoter = {
    last_transaction_version: Scalars["bigint"]["output"];
    operator_address: Scalars["String"]["output"];
    /** An array relationship */
    operator_aptos_name: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    operator_aptos_name_aggregate: CurrentAptosNamesAggregate;
    staking_pool_address: Scalars["String"]["output"];
    voter_address: Scalars["String"]["output"];
};
/** columns and relationships of "current_staking_pool_voter" */
type CurrentStakingPoolVoterOperatorAptosNameArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "current_staking_pool_voter" */
type CurrentStakingPoolVoterOperatorAptosNameAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** Boolean expression to filter rows from the table "current_staking_pool_voter". All fields are combined with a logical 'AND'. */
type CurrentStakingPoolVoterBoolExp = {
    _and?: InputMaybe<Array<CurrentStakingPoolVoterBoolExp>>;
    _not?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
    _or?: InputMaybe<Array<CurrentStakingPoolVoterBoolExp>>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    operator_address?: InputMaybe<StringComparisonExp>;
    operator_aptos_name?: InputMaybe<CurrentAptosNamesBoolExp>;
    operator_aptos_name_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    staking_pool_address?: InputMaybe<StringComparisonExp>;
    voter_address?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_staking_pool_voter". */
type CurrentStakingPoolVoterOrderBy = {
    last_transaction_version?: InputMaybe<OrderBy>;
    operator_address?: InputMaybe<OrderBy>;
    operator_aptos_name_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    staking_pool_address?: InputMaybe<OrderBy>;
    voter_address?: InputMaybe<OrderBy>;
};
/** select columns of table "current_staking_pool_voter" */
declare enum CurrentStakingPoolVoterSelectColumn {
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    OperatorAddress = "operator_address",
    /** column name */
    StakingPoolAddress = "staking_pool_address",
    /** column name */
    VoterAddress = "voter_address"
}
/** Streaming cursor of the table "current_staking_pool_voter" */
type CurrentStakingPoolVoterStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentStakingPoolVoterStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentStakingPoolVoterStreamCursorValueInput = {
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    operator_address?: InputMaybe<Scalars["String"]["input"]>;
    staking_pool_address?: InputMaybe<Scalars["String"]["input"]>;
    voter_address?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_table_items" */
type CurrentTableItems = {
    decoded_key: Scalars["jsonb"]["output"];
    decoded_value?: Maybe<Scalars["jsonb"]["output"]>;
    is_deleted: Scalars["Boolean"]["output"];
    key: Scalars["String"]["output"];
    key_hash: Scalars["String"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    table_handle: Scalars["String"]["output"];
};
/** columns and relationships of "current_table_items" */
type CurrentTableItemsDecodedKeyArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_table_items" */
type CurrentTableItemsDecodedValueArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "current_table_items". All fields are combined with a logical 'AND'. */
type CurrentTableItemsBoolExp = {
    _and?: InputMaybe<Array<CurrentTableItemsBoolExp>>;
    _not?: InputMaybe<CurrentTableItemsBoolExp>;
    _or?: InputMaybe<Array<CurrentTableItemsBoolExp>>;
    decoded_key?: InputMaybe<JsonbComparisonExp>;
    decoded_value?: InputMaybe<JsonbComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    key?: InputMaybe<StringComparisonExp>;
    key_hash?: InputMaybe<StringComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_table_items". */
type CurrentTableItemsOrderBy = {
    decoded_key?: InputMaybe<OrderBy>;
    decoded_value?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    key?: InputMaybe<OrderBy>;
    key_hash?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
};
/** select columns of table "current_table_items" */
declare enum CurrentTableItemsSelectColumn {
    /** column name */
    DecodedKey = "decoded_key",
    /** column name */
    DecodedValue = "decoded_value",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    Key = "key",
    /** column name */
    KeyHash = "key_hash",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    TableHandle = "table_handle"
}
/** Streaming cursor of the table "current_table_items" */
type CurrentTableItemsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentTableItemsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentTableItemsStreamCursorValueInput = {
    decoded_key?: InputMaybe<Scalars["jsonb"]["input"]>;
    decoded_value?: InputMaybe<Scalars["jsonb"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    key?: InputMaybe<Scalars["String"]["input"]>;
    key_hash?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_token_datas" */
type CurrentTokenDatas = {
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    /** An object relationship */
    current_collection_data?: Maybe<CurrentCollectionDatas>;
    default_properties: Scalars["jsonb"]["output"];
    description: Scalars["String"]["output"];
    description_mutable: Scalars["Boolean"]["output"];
    largest_property_version: Scalars["numeric"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    maximum: Scalars["numeric"]["output"];
    maximum_mutable: Scalars["Boolean"]["output"];
    metadata_uri: Scalars["String"]["output"];
    name: Scalars["String"]["output"];
    payee_address: Scalars["String"]["output"];
    properties_mutable: Scalars["Boolean"]["output"];
    royalty_mutable: Scalars["Boolean"]["output"];
    royalty_points_denominator: Scalars["numeric"]["output"];
    royalty_points_numerator: Scalars["numeric"]["output"];
    supply: Scalars["numeric"]["output"];
    token_data_id_hash: Scalars["String"]["output"];
    uri_mutable: Scalars["Boolean"]["output"];
};
/** columns and relationships of "current_token_datas" */
type CurrentTokenDatasDefaultPropertiesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "current_token_datas". All fields are combined with a logical 'AND'. */
type CurrentTokenDatasBoolExp = {
    _and?: InputMaybe<Array<CurrentTokenDatasBoolExp>>;
    _not?: InputMaybe<CurrentTokenDatasBoolExp>;
    _or?: InputMaybe<Array<CurrentTokenDatasBoolExp>>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_collection_data?: InputMaybe<CurrentCollectionDatasBoolExp>;
    default_properties?: InputMaybe<JsonbComparisonExp>;
    description?: InputMaybe<StringComparisonExp>;
    description_mutable?: InputMaybe<BooleanComparisonExp>;
    largest_property_version?: InputMaybe<NumericComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    maximum?: InputMaybe<NumericComparisonExp>;
    maximum_mutable?: InputMaybe<BooleanComparisonExp>;
    metadata_uri?: InputMaybe<StringComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    payee_address?: InputMaybe<StringComparisonExp>;
    properties_mutable?: InputMaybe<BooleanComparisonExp>;
    royalty_mutable?: InputMaybe<BooleanComparisonExp>;
    royalty_points_denominator?: InputMaybe<NumericComparisonExp>;
    royalty_points_numerator?: InputMaybe<NumericComparisonExp>;
    supply?: InputMaybe<NumericComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
    uri_mutable?: InputMaybe<BooleanComparisonExp>;
};
/** Ordering options when selecting data from "current_token_datas". */
type CurrentTokenDatasOrderBy = {
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_collection_data?: InputMaybe<CurrentCollectionDatasOrderBy>;
    default_properties?: InputMaybe<OrderBy>;
    description?: InputMaybe<OrderBy>;
    description_mutable?: InputMaybe<OrderBy>;
    largest_property_version?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    maximum?: InputMaybe<OrderBy>;
    maximum_mutable?: InputMaybe<OrderBy>;
    metadata_uri?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    payee_address?: InputMaybe<OrderBy>;
    properties_mutable?: InputMaybe<OrderBy>;
    royalty_mutable?: InputMaybe<OrderBy>;
    royalty_points_denominator?: InputMaybe<OrderBy>;
    royalty_points_numerator?: InputMaybe<OrderBy>;
    supply?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    uri_mutable?: InputMaybe<OrderBy>;
};
/** select columns of table "current_token_datas" */
declare enum CurrentTokenDatasSelectColumn {
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    DefaultProperties = "default_properties",
    /** column name */
    Description = "description",
    /** column name */
    DescriptionMutable = "description_mutable",
    /** column name */
    LargestPropertyVersion = "largest_property_version",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Maximum = "maximum",
    /** column name */
    MaximumMutable = "maximum_mutable",
    /** column name */
    MetadataUri = "metadata_uri",
    /** column name */
    Name = "name",
    /** column name */
    PayeeAddress = "payee_address",
    /** column name */
    PropertiesMutable = "properties_mutable",
    /** column name */
    RoyaltyMutable = "royalty_mutable",
    /** column name */
    RoyaltyPointsDenominator = "royalty_points_denominator",
    /** column name */
    RoyaltyPointsNumerator = "royalty_points_numerator",
    /** column name */
    Supply = "supply",
    /** column name */
    TokenDataIdHash = "token_data_id_hash",
    /** column name */
    UriMutable = "uri_mutable"
}
/** Streaming cursor of the table "current_token_datas" */
type CurrentTokenDatasStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentTokenDatasStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentTokenDatasStreamCursorValueInput = {
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    default_properties?: InputMaybe<Scalars["jsonb"]["input"]>;
    description?: InputMaybe<Scalars["String"]["input"]>;
    description_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    largest_property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    maximum?: InputMaybe<Scalars["numeric"]["input"]>;
    maximum_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    metadata_uri?: InputMaybe<Scalars["String"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    payee_address?: InputMaybe<Scalars["String"]["input"]>;
    properties_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    royalty_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    royalty_points_denominator?: InputMaybe<Scalars["numeric"]["input"]>;
    royalty_points_numerator?: InputMaybe<Scalars["numeric"]["input"]>;
    supply?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    uri_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** columns and relationships of "current_token_datas_v2" */
type CurrentTokenDatasV2 = {
    /** An object relationship */
    aptos_name?: Maybe<CurrentAptosNames>;
    /** An object relationship */
    cdn_asset_uris?: Maybe<NftMetadataCrawlerParsedAssetUris>;
    collection_id: Scalars["String"]["output"];
    /** An object relationship */
    current_collection?: Maybe<CurrentCollectionsV2>;
    /** An array relationship */
    current_token_ownerships: Array<CurrentTokenOwnershipsV2>;
    /** An aggregate relationship */
    current_token_ownerships_aggregate: CurrentTokenOwnershipsV2Aggregate;
    decimals: Scalars["bigint"]["output"];
    description: Scalars["String"]["output"];
    is_fungible_v2?: Maybe<Scalars["Boolean"]["output"]>;
    largest_property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    maximum?: Maybe<Scalars["numeric"]["output"]>;
    supply: Scalars["numeric"]["output"];
    token_data_id: Scalars["String"]["output"];
    token_name: Scalars["String"]["output"];
    token_properties: Scalars["jsonb"]["output"];
    token_standard: Scalars["String"]["output"];
    token_uri: Scalars["String"]["output"];
};
/** columns and relationships of "current_token_datas_v2" */
type CurrentTokenDatasV2CurrentTokenOwnershipsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
/** columns and relationships of "current_token_datas_v2" */
type CurrentTokenDatasV2CurrentTokenOwnershipsAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
/** columns and relationships of "current_token_datas_v2" */
type CurrentTokenDatasV2TokenPropertiesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "current_token_datas_v2". All fields are combined with a logical 'AND'. */
type CurrentTokenDatasV2BoolExp = {
    _and?: InputMaybe<Array<CurrentTokenDatasV2BoolExp>>;
    _not?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    _or?: InputMaybe<Array<CurrentTokenDatasV2BoolExp>>;
    aptos_name?: InputMaybe<CurrentAptosNamesBoolExp>;
    cdn_asset_uris?: InputMaybe<NftMetadataCrawlerParsedAssetUrisBoolExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    current_collection?: InputMaybe<CurrentCollectionsV2BoolExp>;
    current_token_ownerships?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
    current_token_ownerships_aggregate?: InputMaybe<CurrentTokenOwnershipsV2AggregateBoolExp>;
    decimals?: InputMaybe<BigintComparisonExp>;
    description?: InputMaybe<StringComparisonExp>;
    is_fungible_v2?: InputMaybe<BooleanComparisonExp>;
    largest_property_version_v1?: InputMaybe<NumericComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    maximum?: InputMaybe<NumericComparisonExp>;
    supply?: InputMaybe<NumericComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_name?: InputMaybe<StringComparisonExp>;
    token_properties?: InputMaybe<JsonbComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
    token_uri?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_token_datas_v2". */
type CurrentTokenDatasV2OrderBy = {
    aptos_name?: InputMaybe<CurrentAptosNamesOrderBy>;
    cdn_asset_uris?: InputMaybe<NftMetadataCrawlerParsedAssetUrisOrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    current_collection?: InputMaybe<CurrentCollectionsV2OrderBy>;
    current_token_ownerships_aggregate?: InputMaybe<CurrentTokenOwnershipsV2AggregateOrderBy>;
    decimals?: InputMaybe<OrderBy>;
    description?: InputMaybe<OrderBy>;
    is_fungible_v2?: InputMaybe<OrderBy>;
    largest_property_version_v1?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    maximum?: InputMaybe<OrderBy>;
    supply?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
    token_properties?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    token_uri?: InputMaybe<OrderBy>;
};
/** select columns of table "current_token_datas_v2" */
declare enum CurrentTokenDatasV2SelectColumn {
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    Decimals = "decimals",
    /** column name */
    Description = "description",
    /** column name */
    IsFungibleV2 = "is_fungible_v2",
    /** column name */
    LargestPropertyVersionV1 = "largest_property_version_v1",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Maximum = "maximum",
    /** column name */
    Supply = "supply",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenName = "token_name",
    /** column name */
    TokenProperties = "token_properties",
    /** column name */
    TokenStandard = "token_standard",
    /** column name */
    TokenUri = "token_uri"
}
/** Streaming cursor of the table "current_token_datas_v2" */
type CurrentTokenDatasV2StreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentTokenDatasV2StreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentTokenDatasV2StreamCursorValueInput = {
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    decimals?: InputMaybe<Scalars["bigint"]["input"]>;
    description?: InputMaybe<Scalars["String"]["input"]>;
    is_fungible_v2?: InputMaybe<Scalars["Boolean"]["input"]>;
    largest_property_version_v1?: InputMaybe<Scalars["numeric"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    maximum?: InputMaybe<Scalars["numeric"]["input"]>;
    supply?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_name?: InputMaybe<Scalars["String"]["input"]>;
    token_properties?: InputMaybe<Scalars["jsonb"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
    token_uri?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "current_token_ownerships" */
type CurrentTokenOwnerships = {
    amount: Scalars["numeric"]["output"];
    /** An object relationship */
    aptos_name?: Maybe<CurrentAptosNames>;
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    /** An object relationship */
    current_collection_data?: Maybe<CurrentCollectionDatas>;
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatas>;
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    name: Scalars["String"]["output"];
    owner_address: Scalars["String"]["output"];
    property_version: Scalars["numeric"]["output"];
    table_type: Scalars["String"]["output"];
    token_data_id_hash: Scalars["String"]["output"];
    token_properties: Scalars["jsonb"]["output"];
};
/** columns and relationships of "current_token_ownerships" */
type CurrentTokenOwnershipsTokenPropertiesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregated selection of "current_token_ownerships" */
type CurrentTokenOwnershipsAggregate = {
    aggregate?: Maybe<CurrentTokenOwnershipsAggregateFields>;
    nodes: Array<CurrentTokenOwnerships>;
};
type CurrentTokenOwnershipsAggregateBoolExp = {
    count?: InputMaybe<CurrentTokenOwnershipsAggregateBoolExpCount>;
};
type CurrentTokenOwnershipsAggregateBoolExpCount = {
    arguments?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
    predicate: IntComparisonExp;
};
/** aggregate fields of "current_token_ownerships" */
type CurrentTokenOwnershipsAggregateFields = {
    avg?: Maybe<CurrentTokenOwnershipsAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<CurrentTokenOwnershipsMaxFields>;
    min?: Maybe<CurrentTokenOwnershipsMinFields>;
    stddev?: Maybe<CurrentTokenOwnershipsStddevFields>;
    stddev_pop?: Maybe<CurrentTokenOwnershipsStddevPopFields>;
    stddev_samp?: Maybe<CurrentTokenOwnershipsStddevSampFields>;
    sum?: Maybe<CurrentTokenOwnershipsSumFields>;
    var_pop?: Maybe<CurrentTokenOwnershipsVarPopFields>;
    var_samp?: Maybe<CurrentTokenOwnershipsVarSampFields>;
    variance?: Maybe<CurrentTokenOwnershipsVarianceFields>;
};
/** aggregate fields of "current_token_ownerships" */
type CurrentTokenOwnershipsAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** order by aggregate values of table "current_token_ownerships" */
type CurrentTokenOwnershipsAggregateOrderBy = {
    avg?: InputMaybe<CurrentTokenOwnershipsAvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<CurrentTokenOwnershipsMaxOrderBy>;
    min?: InputMaybe<CurrentTokenOwnershipsMinOrderBy>;
    stddev?: InputMaybe<CurrentTokenOwnershipsStddevOrderBy>;
    stddev_pop?: InputMaybe<CurrentTokenOwnershipsStddevPopOrderBy>;
    stddev_samp?: InputMaybe<CurrentTokenOwnershipsStddevSampOrderBy>;
    sum?: InputMaybe<CurrentTokenOwnershipsSumOrderBy>;
    var_pop?: InputMaybe<CurrentTokenOwnershipsVarPopOrderBy>;
    var_samp?: InputMaybe<CurrentTokenOwnershipsVarSampOrderBy>;
    variance?: InputMaybe<CurrentTokenOwnershipsVarianceOrderBy>;
};
/** aggregate avg on columns */
type CurrentTokenOwnershipsAvgFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by avg() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsAvgOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "current_token_ownerships". All fields are combined with a logical 'AND'. */
type CurrentTokenOwnershipsBoolExp = {
    _and?: InputMaybe<Array<CurrentTokenOwnershipsBoolExp>>;
    _not?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
    _or?: InputMaybe<Array<CurrentTokenOwnershipsBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    aptos_name?: InputMaybe<CurrentAptosNamesBoolExp>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_collection_data?: InputMaybe<CurrentCollectionDatasBoolExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasBoolExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    property_version?: InputMaybe<NumericComparisonExp>;
    table_type?: InputMaybe<StringComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
    token_properties?: InputMaybe<JsonbComparisonExp>;
};
/** aggregate max on columns */
type CurrentTokenOwnershipsMaxFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    collection_data_id_hash?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    name?: Maybe<Scalars["String"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    property_version?: Maybe<Scalars["numeric"]["output"]>;
    table_type?: Maybe<Scalars["String"]["output"]>;
    token_data_id_hash?: Maybe<Scalars["String"]["output"]>;
};
/** order by max() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsMaxOrderBy = {
    amount?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    table_type?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
};
/** aggregate min on columns */
type CurrentTokenOwnershipsMinFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    collection_data_id_hash?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    name?: Maybe<Scalars["String"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    property_version?: Maybe<Scalars["numeric"]["output"]>;
    table_type?: Maybe<Scalars["String"]["output"]>;
    token_data_id_hash?: Maybe<Scalars["String"]["output"]>;
};
/** order by min() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsMinOrderBy = {
    amount?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    table_type?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "current_token_ownerships". */
type CurrentTokenOwnershipsOrderBy = {
    amount?: InputMaybe<OrderBy>;
    aptos_name?: InputMaybe<CurrentAptosNamesOrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_collection_data?: InputMaybe<CurrentCollectionDatasOrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasOrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    table_type?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    token_properties?: InputMaybe<OrderBy>;
};
/** select columns of table "current_token_ownerships" */
declare enum CurrentTokenOwnershipsSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Name = "name",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    PropertyVersion = "property_version",
    /** column name */
    TableType = "table_type",
    /** column name */
    TokenDataIdHash = "token_data_id_hash",
    /** column name */
    TokenProperties = "token_properties"
}
/** aggregate stddev on columns */
type CurrentTokenOwnershipsStddevFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsStddevOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_pop on columns */
type CurrentTokenOwnershipsStddevPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_pop() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsStddevPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_samp on columns */
type CurrentTokenOwnershipsStddevSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_samp() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsStddevSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "current_token_ownerships" */
type CurrentTokenOwnershipsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentTokenOwnershipsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentTokenOwnershipsStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    table_type?: InputMaybe<Scalars["String"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    token_properties?: InputMaybe<Scalars["jsonb"]["input"]>;
};
/** aggregate sum on columns */
type CurrentTokenOwnershipsSumFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    property_version?: Maybe<Scalars["numeric"]["output"]>;
};
/** order by sum() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsSumOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2 = {
    amount: Scalars["numeric"]["output"];
    /** An array relationship */
    composed_nfts: Array<CurrentTokenOwnershipsV2>;
    /** An aggregate relationship */
    composed_nfts_aggregate: CurrentTokenOwnershipsV2Aggregate;
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatasV2>;
    is_fungible_v2?: Maybe<Scalars["Boolean"]["output"]>;
    is_soulbound_v2?: Maybe<Scalars["Boolean"]["output"]>;
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    non_transferrable_by_owner?: Maybe<Scalars["Boolean"]["output"]>;
    owner_address: Scalars["String"]["output"];
    property_version_v1: Scalars["numeric"]["output"];
    storage_id: Scalars["String"]["output"];
    table_type_v1?: Maybe<Scalars["String"]["output"]>;
    token_data_id: Scalars["String"]["output"];
    token_properties_mutated_v1?: Maybe<Scalars["jsonb"]["output"]>;
    token_standard: Scalars["String"]["output"];
};
/** columns and relationships of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2ComposedNftsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
/** columns and relationships of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2ComposedNftsAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
/** columns and relationships of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2TokenPropertiesMutatedV1Args = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregated selection of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2Aggregate = {
    aggregate?: Maybe<CurrentTokenOwnershipsV2AggregateFields>;
    nodes: Array<CurrentTokenOwnershipsV2>;
};
type CurrentTokenOwnershipsV2AggregateBoolExp = {
    bool_and?: InputMaybe<CurrentTokenOwnershipsV2AggregateBoolExpBoolAnd>;
    bool_or?: InputMaybe<CurrentTokenOwnershipsV2AggregateBoolExpBoolOr>;
    count?: InputMaybe<CurrentTokenOwnershipsV2AggregateBoolExpCount>;
};
type CurrentTokenOwnershipsV2AggregateBoolExpBoolAnd = {
    arguments: CurrentTokenOwnershipsV2SelectColumnCurrentTokenOwnershipsV2AggregateBoolExpBoolAndArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
    predicate: BooleanComparisonExp;
};
type CurrentTokenOwnershipsV2AggregateBoolExpBoolOr = {
    arguments: CurrentTokenOwnershipsV2SelectColumnCurrentTokenOwnershipsV2AggregateBoolExpBoolOrArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
    predicate: BooleanComparisonExp;
};
type CurrentTokenOwnershipsV2AggregateBoolExpCount = {
    arguments?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
    predicate: IntComparisonExp;
};
/** aggregate fields of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2AggregateFields = {
    avg?: Maybe<CurrentTokenOwnershipsV2AvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<CurrentTokenOwnershipsV2MaxFields>;
    min?: Maybe<CurrentTokenOwnershipsV2MinFields>;
    stddev?: Maybe<CurrentTokenOwnershipsV2StddevFields>;
    stddev_pop?: Maybe<CurrentTokenOwnershipsV2StddevPopFields>;
    stddev_samp?: Maybe<CurrentTokenOwnershipsV2StddevSampFields>;
    sum?: Maybe<CurrentTokenOwnershipsV2SumFields>;
    var_pop?: Maybe<CurrentTokenOwnershipsV2VarPopFields>;
    var_samp?: Maybe<CurrentTokenOwnershipsV2VarSampFields>;
    variance?: Maybe<CurrentTokenOwnershipsV2VarianceFields>;
};
/** aggregate fields of "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2AggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** order by aggregate values of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2AggregateOrderBy = {
    avg?: InputMaybe<CurrentTokenOwnershipsV2AvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<CurrentTokenOwnershipsV2MaxOrderBy>;
    min?: InputMaybe<CurrentTokenOwnershipsV2MinOrderBy>;
    stddev?: InputMaybe<CurrentTokenOwnershipsV2StddevOrderBy>;
    stddev_pop?: InputMaybe<CurrentTokenOwnershipsV2StddevPopOrderBy>;
    stddev_samp?: InputMaybe<CurrentTokenOwnershipsV2StddevSampOrderBy>;
    sum?: InputMaybe<CurrentTokenOwnershipsV2SumOrderBy>;
    var_pop?: InputMaybe<CurrentTokenOwnershipsV2VarPopOrderBy>;
    var_samp?: InputMaybe<CurrentTokenOwnershipsV2VarSampOrderBy>;
    variance?: InputMaybe<CurrentTokenOwnershipsV2VarianceOrderBy>;
};
/** aggregate avg on columns */
type CurrentTokenOwnershipsV2AvgFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by avg() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2AvgOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "current_token_ownerships_v2". All fields are combined with a logical 'AND'. */
type CurrentTokenOwnershipsV2BoolExp = {
    _and?: InputMaybe<Array<CurrentTokenOwnershipsV2BoolExp>>;
    _not?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
    _or?: InputMaybe<Array<CurrentTokenOwnershipsV2BoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    composed_nfts?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
    composed_nfts_aggregate?: InputMaybe<CurrentTokenOwnershipsV2AggregateBoolExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    is_fungible_v2?: InputMaybe<BooleanComparisonExp>;
    is_soulbound_v2?: InputMaybe<BooleanComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    non_transferrable_by_owner?: InputMaybe<BooleanComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    property_version_v1?: InputMaybe<NumericComparisonExp>;
    storage_id?: InputMaybe<StringComparisonExp>;
    table_type_v1?: InputMaybe<StringComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_properties_mutated_v1?: InputMaybe<JsonbComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type CurrentTokenOwnershipsV2MaxFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
    storage_id?: Maybe<Scalars["String"]["output"]>;
    table_type_v1?: Maybe<Scalars["String"]["output"]>;
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** order by max() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2MaxOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    table_type_v1?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** aggregate min on columns */
type CurrentTokenOwnershipsV2MinFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    owner_address?: Maybe<Scalars["String"]["output"]>;
    property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
    storage_id?: Maybe<Scalars["String"]["output"]>;
    table_type_v1?: Maybe<Scalars["String"]["output"]>;
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** order by min() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2MinOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    table_type_v1?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "current_token_ownerships_v2". */
type CurrentTokenOwnershipsV2OrderBy = {
    amount?: InputMaybe<OrderBy>;
    composed_nfts_aggregate?: InputMaybe<CurrentTokenOwnershipsV2AggregateOrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    is_fungible_v2?: InputMaybe<OrderBy>;
    is_soulbound_v2?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    non_transferrable_by_owner?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    table_type_v1?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_properties_mutated_v1?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "current_token_ownerships_v2" */
declare enum CurrentTokenOwnershipsV2SelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    IsFungibleV2 = "is_fungible_v2",
    /** column name */
    IsSoulboundV2 = "is_soulbound_v2",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    NonTransferrableByOwner = "non_transferrable_by_owner",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    PropertyVersionV1 = "property_version_v1",
    /** column name */
    StorageId = "storage_id",
    /** column name */
    TableTypeV1 = "table_type_v1",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenPropertiesMutatedV1 = "token_properties_mutated_v1",
    /** column name */
    TokenStandard = "token_standard"
}
/** select "current_token_ownerships_v2_aggregate_bool_exp_bool_and_arguments_columns" columns of table "current_token_ownerships_v2" */
declare enum CurrentTokenOwnershipsV2SelectColumnCurrentTokenOwnershipsV2AggregateBoolExpBoolAndArgumentsColumns {
    /** column name */
    IsFungibleV2 = "is_fungible_v2",
    /** column name */
    IsSoulboundV2 = "is_soulbound_v2",
    /** column name */
    NonTransferrableByOwner = "non_transferrable_by_owner"
}
/** select "current_token_ownerships_v2_aggregate_bool_exp_bool_or_arguments_columns" columns of table "current_token_ownerships_v2" */
declare enum CurrentTokenOwnershipsV2SelectColumnCurrentTokenOwnershipsV2AggregateBoolExpBoolOrArgumentsColumns {
    /** column name */
    IsFungibleV2 = "is_fungible_v2",
    /** column name */
    IsSoulboundV2 = "is_soulbound_v2",
    /** column name */
    NonTransferrableByOwner = "non_transferrable_by_owner"
}
/** aggregate stddev on columns */
type CurrentTokenOwnershipsV2StddevFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2StddevOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** aggregate stddev_pop on columns */
type CurrentTokenOwnershipsV2StddevPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_pop() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2StddevPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** aggregate stddev_samp on columns */
type CurrentTokenOwnershipsV2StddevSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_samp() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2StddevSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2StreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentTokenOwnershipsV2StreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentTokenOwnershipsV2StreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    is_fungible_v2?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_soulbound_v2?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    non_transferrable_by_owner?: InputMaybe<Scalars["Boolean"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    property_version_v1?: InputMaybe<Scalars["numeric"]["input"]>;
    storage_id?: InputMaybe<Scalars["String"]["input"]>;
    table_type_v1?: InputMaybe<Scalars["String"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_properties_mutated_v1?: InputMaybe<Scalars["jsonb"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type CurrentTokenOwnershipsV2SumFields = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
};
/** order by sum() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2SumOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** aggregate var_pop on columns */
type CurrentTokenOwnershipsV2VarPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_pop() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2VarPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** aggregate var_samp on columns */
type CurrentTokenOwnershipsV2VarSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_samp() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2VarSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** aggregate variance on columns */
type CurrentTokenOwnershipsV2VarianceFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
};
/** order by variance() on columns of table "current_token_ownerships_v2" */
type CurrentTokenOwnershipsV2VarianceOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
};
/** aggregate var_pop on columns */
type CurrentTokenOwnershipsVarPopFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_pop() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsVarPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** aggregate var_samp on columns */
type CurrentTokenOwnershipsVarSampFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_samp() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsVarSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** aggregate variance on columns */
type CurrentTokenOwnershipsVarianceFields = {
    amount?: Maybe<Scalars["Float"]["output"]>;
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by variance() on columns of table "current_token_ownerships" */
type CurrentTokenOwnershipsVarianceOrderBy = {
    amount?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "current_token_pending_claims" */
type CurrentTokenPendingClaims = {
    amount: Scalars["numeric"]["output"];
    collection_data_id_hash: Scalars["String"]["output"];
    collection_id: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    /** An object relationship */
    current_collection_data?: Maybe<CurrentCollectionDatas>;
    /** An object relationship */
    current_collection_v2?: Maybe<CurrentCollectionsV2>;
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatas>;
    /** An object relationship */
    current_token_data_v2?: Maybe<CurrentTokenDatasV2>;
    from_address: Scalars["String"]["output"];
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    name: Scalars["String"]["output"];
    property_version: Scalars["numeric"]["output"];
    table_handle: Scalars["String"]["output"];
    to_address: Scalars["String"]["output"];
    /** An object relationship */
    token?: Maybe<Tokens>;
    token_data_id: Scalars["String"]["output"];
    token_data_id_hash: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "current_token_pending_claims". All fields are combined with a logical 'AND'. */
type CurrentTokenPendingClaimsBoolExp = {
    _and?: InputMaybe<Array<CurrentTokenPendingClaimsBoolExp>>;
    _not?: InputMaybe<CurrentTokenPendingClaimsBoolExp>;
    _or?: InputMaybe<Array<CurrentTokenPendingClaimsBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_collection_data?: InputMaybe<CurrentCollectionDatasBoolExp>;
    current_collection_v2?: InputMaybe<CurrentCollectionsV2BoolExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasBoolExp>;
    current_token_data_v2?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    from_address?: InputMaybe<StringComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    property_version?: InputMaybe<NumericComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
    to_address?: InputMaybe<StringComparisonExp>;
    token?: InputMaybe<TokensBoolExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "current_token_pending_claims". */
type CurrentTokenPendingClaimsOrderBy = {
    amount?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_collection_data?: InputMaybe<CurrentCollectionDatasOrderBy>;
    current_collection_v2?: InputMaybe<CurrentCollectionsV2OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasOrderBy>;
    current_token_data_v2?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token?: InputMaybe<TokensOrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
};
/** select columns of table "current_token_pending_claims" */
declare enum CurrentTokenPendingClaimsSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    FromAddress = "from_address",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Name = "name",
    /** column name */
    PropertyVersion = "property_version",
    /** column name */
    TableHandle = "table_handle",
    /** column name */
    ToAddress = "to_address",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenDataIdHash = "token_data_id_hash"
}
/** Streaming cursor of the table "current_token_pending_claims" */
type CurrentTokenPendingClaimsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: CurrentTokenPendingClaimsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type CurrentTokenPendingClaimsStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    from_address?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
    to_address?: InputMaybe<Scalars["String"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
};
/** ordering argument of a cursor */
declare enum CursorOrdering {
    /** ascending ordering of the cursor */
    Asc = "ASC",
    /** descending ordering of the cursor */
    Desc = "DESC"
}
/** columns and relationships of "delegated_staking_activities" */
type DelegatedStakingActivities = {
    amount: Scalars["numeric"]["output"];
    delegator_address: Scalars["String"]["output"];
    event_index: Scalars["bigint"]["output"];
    event_type: Scalars["String"]["output"];
    pool_address: Scalars["String"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** order by aggregate values of table "delegated_staking_activities" */
type DelegatedStakingActivitiesAggregateOrderBy = {
    avg?: InputMaybe<DelegatedStakingActivitiesAvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<DelegatedStakingActivitiesMaxOrderBy>;
    min?: InputMaybe<DelegatedStakingActivitiesMinOrderBy>;
    stddev?: InputMaybe<DelegatedStakingActivitiesStddevOrderBy>;
    stddev_pop?: InputMaybe<DelegatedStakingActivitiesStddevPopOrderBy>;
    stddev_samp?: InputMaybe<DelegatedStakingActivitiesStddevSampOrderBy>;
    sum?: InputMaybe<DelegatedStakingActivitiesSumOrderBy>;
    var_pop?: InputMaybe<DelegatedStakingActivitiesVarPopOrderBy>;
    var_samp?: InputMaybe<DelegatedStakingActivitiesVarSampOrderBy>;
    variance?: InputMaybe<DelegatedStakingActivitiesVarianceOrderBy>;
};
/** order by avg() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesAvgOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "delegated_staking_activities". All fields are combined with a logical 'AND'. */
type DelegatedStakingActivitiesBoolExp = {
    _and?: InputMaybe<Array<DelegatedStakingActivitiesBoolExp>>;
    _not?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
    _or?: InputMaybe<Array<DelegatedStakingActivitiesBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    delegator_address?: InputMaybe<StringComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    event_type?: InputMaybe<StringComparisonExp>;
    pool_address?: InputMaybe<StringComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** order by max() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesMaxOrderBy = {
    amount?: InputMaybe<OrderBy>;
    delegator_address?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_type?: InputMaybe<OrderBy>;
    pool_address?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by min() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesMinOrderBy = {
    amount?: InputMaybe<OrderBy>;
    delegator_address?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_type?: InputMaybe<OrderBy>;
    pool_address?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "delegated_staking_activities". */
type DelegatedStakingActivitiesOrderBy = {
    amount?: InputMaybe<OrderBy>;
    delegator_address?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_type?: InputMaybe<OrderBy>;
    pool_address?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "delegated_staking_activities" */
declare enum DelegatedStakingActivitiesSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    DelegatorAddress = "delegator_address",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    EventType = "event_type",
    /** column name */
    PoolAddress = "pool_address",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** order by stddev() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesStddevOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by stddev_pop() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesStddevPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by stddev_samp() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesStddevSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "delegated_staking_activities" */
type DelegatedStakingActivitiesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: DelegatedStakingActivitiesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type DelegatedStakingActivitiesStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    delegator_address?: InputMaybe<Scalars["String"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    event_type?: InputMaybe<Scalars["String"]["input"]>;
    pool_address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** order by sum() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesSumOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by var_pop() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesVarPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by var_samp() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesVarSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by variance() on columns of table "delegated_staking_activities" */
type DelegatedStakingActivitiesVarianceOrderBy = {
    amount?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "delegated_staking_pool_balances" */
type DelegatedStakingPoolBalances = {
    active_table_handle: Scalars["String"]["output"];
    inactive_table_handle: Scalars["String"]["output"];
    operator_commission_percentage: Scalars["numeric"]["output"];
    staking_pool_address: Scalars["String"]["output"];
    total_coins: Scalars["numeric"]["output"];
    total_shares: Scalars["numeric"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** aggregated selection of "delegated_staking_pool_balances" */
type DelegatedStakingPoolBalancesAggregate = {
    aggregate?: Maybe<DelegatedStakingPoolBalancesAggregateFields>;
    nodes: Array<DelegatedStakingPoolBalances>;
};
/** aggregate fields of "delegated_staking_pool_balances" */
type DelegatedStakingPoolBalancesAggregateFields = {
    avg?: Maybe<DelegatedStakingPoolBalancesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<DelegatedStakingPoolBalancesMaxFields>;
    min?: Maybe<DelegatedStakingPoolBalancesMinFields>;
    stddev?: Maybe<DelegatedStakingPoolBalancesStddevFields>;
    stddev_pop?: Maybe<DelegatedStakingPoolBalancesStddevPopFields>;
    stddev_samp?: Maybe<DelegatedStakingPoolBalancesStddevSampFields>;
    sum?: Maybe<DelegatedStakingPoolBalancesSumFields>;
    var_pop?: Maybe<DelegatedStakingPoolBalancesVarPopFields>;
    var_samp?: Maybe<DelegatedStakingPoolBalancesVarSampFields>;
    variance?: Maybe<DelegatedStakingPoolBalancesVarianceFields>;
};
/** aggregate fields of "delegated_staking_pool_balances" */
type DelegatedStakingPoolBalancesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<DelegatedStakingPoolBalancesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type DelegatedStakingPoolBalancesAvgFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "delegated_staking_pool_balances". All fields are combined with a logical 'AND'. */
type DelegatedStakingPoolBalancesBoolExp = {
    _and?: InputMaybe<Array<DelegatedStakingPoolBalancesBoolExp>>;
    _not?: InputMaybe<DelegatedStakingPoolBalancesBoolExp>;
    _or?: InputMaybe<Array<DelegatedStakingPoolBalancesBoolExp>>;
    active_table_handle?: InputMaybe<StringComparisonExp>;
    inactive_table_handle?: InputMaybe<StringComparisonExp>;
    operator_commission_percentage?: InputMaybe<NumericComparisonExp>;
    staking_pool_address?: InputMaybe<StringComparisonExp>;
    total_coins?: InputMaybe<NumericComparisonExp>;
    total_shares?: InputMaybe<NumericComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** aggregate max on columns */
type DelegatedStakingPoolBalancesMaxFields = {
    active_table_handle?: Maybe<Scalars["String"]["output"]>;
    inactive_table_handle?: Maybe<Scalars["String"]["output"]>;
    operator_commission_percentage?: Maybe<Scalars["numeric"]["output"]>;
    staking_pool_address?: Maybe<Scalars["String"]["output"]>;
    total_coins?: Maybe<Scalars["numeric"]["output"]>;
    total_shares?: Maybe<Scalars["numeric"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate min on columns */
type DelegatedStakingPoolBalancesMinFields = {
    active_table_handle?: Maybe<Scalars["String"]["output"]>;
    inactive_table_handle?: Maybe<Scalars["String"]["output"]>;
    operator_commission_percentage?: Maybe<Scalars["numeric"]["output"]>;
    staking_pool_address?: Maybe<Scalars["String"]["output"]>;
    total_coins?: Maybe<Scalars["numeric"]["output"]>;
    total_shares?: Maybe<Scalars["numeric"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** Ordering options when selecting data from "delegated_staking_pool_balances". */
type DelegatedStakingPoolBalancesOrderBy = {
    active_table_handle?: InputMaybe<OrderBy>;
    inactive_table_handle?: InputMaybe<OrderBy>;
    operator_commission_percentage?: InputMaybe<OrderBy>;
    staking_pool_address?: InputMaybe<OrderBy>;
    total_coins?: InputMaybe<OrderBy>;
    total_shares?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "delegated_staking_pool_balances" */
declare enum DelegatedStakingPoolBalancesSelectColumn {
    /** column name */
    ActiveTableHandle = "active_table_handle",
    /** column name */
    InactiveTableHandle = "inactive_table_handle",
    /** column name */
    OperatorCommissionPercentage = "operator_commission_percentage",
    /** column name */
    StakingPoolAddress = "staking_pool_address",
    /** column name */
    TotalCoins = "total_coins",
    /** column name */
    TotalShares = "total_shares",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** aggregate stddev on columns */
type DelegatedStakingPoolBalancesStddevFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type DelegatedStakingPoolBalancesStddevPopFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type DelegatedStakingPoolBalancesStddevSampFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "delegated_staking_pool_balances" */
type DelegatedStakingPoolBalancesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: DelegatedStakingPoolBalancesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type DelegatedStakingPoolBalancesStreamCursorValueInput = {
    active_table_handle?: InputMaybe<Scalars["String"]["input"]>;
    inactive_table_handle?: InputMaybe<Scalars["String"]["input"]>;
    operator_commission_percentage?: InputMaybe<Scalars["numeric"]["input"]>;
    staking_pool_address?: InputMaybe<Scalars["String"]["input"]>;
    total_coins?: InputMaybe<Scalars["numeric"]["input"]>;
    total_shares?: InputMaybe<Scalars["numeric"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** aggregate sum on columns */
type DelegatedStakingPoolBalancesSumFields = {
    operator_commission_percentage?: Maybe<Scalars["numeric"]["output"]>;
    total_coins?: Maybe<Scalars["numeric"]["output"]>;
    total_shares?: Maybe<Scalars["numeric"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type DelegatedStakingPoolBalancesVarPopFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type DelegatedStakingPoolBalancesVarSampFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type DelegatedStakingPoolBalancesVarianceFields = {
    operator_commission_percentage?: Maybe<Scalars["Float"]["output"]>;
    total_coins?: Maybe<Scalars["Float"]["output"]>;
    total_shares?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "delegated_staking_pools" */
type DelegatedStakingPools = {
    /** An object relationship */
    current_staking_pool?: Maybe<CurrentStakingPoolVoter>;
    first_transaction_version: Scalars["bigint"]["output"];
    staking_pool_address: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "delegated_staking_pools". All fields are combined with a logical 'AND'. */
type DelegatedStakingPoolsBoolExp = {
    _and?: InputMaybe<Array<DelegatedStakingPoolsBoolExp>>;
    _not?: InputMaybe<DelegatedStakingPoolsBoolExp>;
    _or?: InputMaybe<Array<DelegatedStakingPoolsBoolExp>>;
    current_staking_pool?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
    first_transaction_version?: InputMaybe<BigintComparisonExp>;
    staking_pool_address?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "delegated_staking_pools". */
type DelegatedStakingPoolsOrderBy = {
    current_staking_pool?: InputMaybe<CurrentStakingPoolVoterOrderBy>;
    first_transaction_version?: InputMaybe<OrderBy>;
    staking_pool_address?: InputMaybe<OrderBy>;
};
/** select columns of table "delegated_staking_pools" */
declare enum DelegatedStakingPoolsSelectColumn {
    /** column name */
    FirstTransactionVersion = "first_transaction_version",
    /** column name */
    StakingPoolAddress = "staking_pool_address"
}
/** Streaming cursor of the table "delegated_staking_pools" */
type DelegatedStakingPoolsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: DelegatedStakingPoolsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type DelegatedStakingPoolsStreamCursorValueInput = {
    first_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    staking_pool_address?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "delegator_distinct_pool" */
type DelegatorDistinctPool = {
    /** An object relationship */
    current_pool_balance?: Maybe<CurrentDelegatedStakingPoolBalances>;
    delegator_address?: Maybe<Scalars["String"]["output"]>;
    pool_address?: Maybe<Scalars["String"]["output"]>;
    /** An object relationship */
    staking_pool_metadata?: Maybe<CurrentStakingPoolVoter>;
};
/** aggregated selection of "delegator_distinct_pool" */
type DelegatorDistinctPoolAggregate = {
    aggregate?: Maybe<DelegatorDistinctPoolAggregateFields>;
    nodes: Array<DelegatorDistinctPool>;
};
/** aggregate fields of "delegator_distinct_pool" */
type DelegatorDistinctPoolAggregateFields = {
    count: Scalars["Int"]["output"];
    max?: Maybe<DelegatorDistinctPoolMaxFields>;
    min?: Maybe<DelegatorDistinctPoolMinFields>;
};
/** aggregate fields of "delegator_distinct_pool" */
type DelegatorDistinctPoolAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<DelegatorDistinctPoolSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** Boolean expression to filter rows from the table "delegator_distinct_pool". All fields are combined with a logical 'AND'. */
type DelegatorDistinctPoolBoolExp = {
    _and?: InputMaybe<Array<DelegatorDistinctPoolBoolExp>>;
    _not?: InputMaybe<DelegatorDistinctPoolBoolExp>;
    _or?: InputMaybe<Array<DelegatorDistinctPoolBoolExp>>;
    current_pool_balance?: InputMaybe<CurrentDelegatedStakingPoolBalancesBoolExp>;
    delegator_address?: InputMaybe<StringComparisonExp>;
    pool_address?: InputMaybe<StringComparisonExp>;
    staking_pool_metadata?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
};
/** aggregate max on columns */
type DelegatorDistinctPoolMaxFields = {
    delegator_address?: Maybe<Scalars["String"]["output"]>;
    pool_address?: Maybe<Scalars["String"]["output"]>;
};
/** aggregate min on columns */
type DelegatorDistinctPoolMinFields = {
    delegator_address?: Maybe<Scalars["String"]["output"]>;
    pool_address?: Maybe<Scalars["String"]["output"]>;
};
/** Ordering options when selecting data from "delegator_distinct_pool". */
type DelegatorDistinctPoolOrderBy = {
    current_pool_balance?: InputMaybe<CurrentDelegatedStakingPoolBalancesOrderBy>;
    delegator_address?: InputMaybe<OrderBy>;
    pool_address?: InputMaybe<OrderBy>;
    staking_pool_metadata?: InputMaybe<CurrentStakingPoolVoterOrderBy>;
};
/** select columns of table "delegator_distinct_pool" */
declare enum DelegatorDistinctPoolSelectColumn {
    /** column name */
    DelegatorAddress = "delegator_address",
    /** column name */
    PoolAddress = "pool_address"
}
/** Streaming cursor of the table "delegator_distinct_pool" */
type DelegatorDistinctPoolStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: DelegatorDistinctPoolStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type DelegatorDistinctPoolStreamCursorValueInput = {
    delegator_address?: InputMaybe<Scalars["String"]["input"]>;
    pool_address?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "events" */
type Events = {
    account_address: Scalars["String"]["output"];
    creation_number: Scalars["bigint"]["output"];
    data: Scalars["jsonb"]["output"];
    event_index: Scalars["bigint"]["output"];
    indexed_type: Scalars["String"]["output"];
    sequence_number: Scalars["bigint"]["output"];
    transaction_block_height: Scalars["bigint"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    type: Scalars["String"]["output"];
};
/** columns and relationships of "events" */
type EventsDataArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "events". All fields are combined with a logical 'AND'. */
type EventsBoolExp = {
    _and?: InputMaybe<Array<EventsBoolExp>>;
    _not?: InputMaybe<EventsBoolExp>;
    _or?: InputMaybe<Array<EventsBoolExp>>;
    account_address?: InputMaybe<StringComparisonExp>;
    creation_number?: InputMaybe<BigintComparisonExp>;
    data?: InputMaybe<JsonbComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    indexed_type?: InputMaybe<StringComparisonExp>;
    sequence_number?: InputMaybe<BigintComparisonExp>;
    transaction_block_height?: InputMaybe<BigintComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    type?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "events". */
type EventsOrderBy = {
    account_address?: InputMaybe<OrderBy>;
    creation_number?: InputMaybe<OrderBy>;
    data?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    indexed_type?: InputMaybe<OrderBy>;
    sequence_number?: InputMaybe<OrderBy>;
    transaction_block_height?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** select columns of table "events" */
declare enum EventsSelectColumn {
    /** column name */
    AccountAddress = "account_address",
    /** column name */
    CreationNumber = "creation_number",
    /** column name */
    Data = "data",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    IndexedType = "indexed_type",
    /** column name */
    SequenceNumber = "sequence_number",
    /** column name */
    TransactionBlockHeight = "transaction_block_height",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    Type = "type"
}
/** Streaming cursor of the table "events" */
type EventsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: EventsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type EventsStreamCursorValueInput = {
    account_address?: InputMaybe<Scalars["String"]["input"]>;
    creation_number?: InputMaybe<Scalars["bigint"]["input"]>;
    data?: InputMaybe<Scalars["jsonb"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    indexed_type?: InputMaybe<Scalars["String"]["input"]>;
    sequence_number?: InputMaybe<Scalars["bigint"]["input"]>;
    transaction_block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    type?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "fungible_asset_activities" */
type FungibleAssetActivities = {
    amount?: Maybe<Scalars["numeric"]["output"]>;
    asset_type: Scalars["String"]["output"];
    block_height: Scalars["bigint"]["output"];
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_index: Scalars["bigint"]["output"];
    gas_fee_payer_address?: Maybe<Scalars["String"]["output"]>;
    is_frozen?: Maybe<Scalars["Boolean"]["output"]>;
    is_gas_fee: Scalars["Boolean"]["output"];
    is_transaction_success: Scalars["Boolean"]["output"];
    /** An object relationship */
    metadata?: Maybe<FungibleAssetMetadata>;
    owner_address: Scalars["String"]["output"];
    /** An array relationship */
    owner_aptos_names: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    owner_aptos_names_aggregate: CurrentAptosNamesAggregate;
    storage_id: Scalars["String"]["output"];
    storage_refund_amount: Scalars["numeric"]["output"];
    token_standard: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    type: Scalars["String"]["output"];
};
/** columns and relationships of "fungible_asset_activities" */
type FungibleAssetActivitiesOwnerAptosNamesArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "fungible_asset_activities" */
type FungibleAssetActivitiesOwnerAptosNamesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** order by aggregate values of table "fungible_asset_activities" */
type FungibleAssetActivitiesAggregateOrderBy = {
    avg?: InputMaybe<FungibleAssetActivitiesAvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<FungibleAssetActivitiesMaxOrderBy>;
    min?: InputMaybe<FungibleAssetActivitiesMinOrderBy>;
    stddev?: InputMaybe<FungibleAssetActivitiesStddevOrderBy>;
    stddev_pop?: InputMaybe<FungibleAssetActivitiesStddevPopOrderBy>;
    stddev_samp?: InputMaybe<FungibleAssetActivitiesStddevSampOrderBy>;
    sum?: InputMaybe<FungibleAssetActivitiesSumOrderBy>;
    var_pop?: InputMaybe<FungibleAssetActivitiesVarPopOrderBy>;
    var_samp?: InputMaybe<FungibleAssetActivitiesVarSampOrderBy>;
    variance?: InputMaybe<FungibleAssetActivitiesVarianceOrderBy>;
};
/** order by avg() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesAvgOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "fungible_asset_activities". All fields are combined with a logical 'AND'. */
type FungibleAssetActivitiesBoolExp = {
    _and?: InputMaybe<Array<FungibleAssetActivitiesBoolExp>>;
    _not?: InputMaybe<FungibleAssetActivitiesBoolExp>;
    _or?: InputMaybe<Array<FungibleAssetActivitiesBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    asset_type?: InputMaybe<StringComparisonExp>;
    block_height?: InputMaybe<BigintComparisonExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    gas_fee_payer_address?: InputMaybe<StringComparisonExp>;
    is_frozen?: InputMaybe<BooleanComparisonExp>;
    is_gas_fee?: InputMaybe<BooleanComparisonExp>;
    is_transaction_success?: InputMaybe<BooleanComparisonExp>;
    metadata?: InputMaybe<FungibleAssetMetadataBoolExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    owner_aptos_names?: InputMaybe<CurrentAptosNamesBoolExp>;
    owner_aptos_names_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    storage_id?: InputMaybe<StringComparisonExp>;
    storage_refund_amount?: InputMaybe<NumericComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    type?: InputMaybe<StringComparisonExp>;
};
/** order by max() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesMaxOrderBy = {
    amount?: InputMaybe<OrderBy>;
    asset_type?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    gas_fee_payer_address?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** order by min() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesMinOrderBy = {
    amount?: InputMaybe<OrderBy>;
    asset_type?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    gas_fee_payer_address?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "fungible_asset_activities". */
type FungibleAssetActivitiesOrderBy = {
    amount?: InputMaybe<OrderBy>;
    asset_type?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    gas_fee_payer_address?: InputMaybe<OrderBy>;
    is_frozen?: InputMaybe<OrderBy>;
    is_gas_fee?: InputMaybe<OrderBy>;
    is_transaction_success?: InputMaybe<OrderBy>;
    metadata?: InputMaybe<FungibleAssetMetadataOrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    owner_aptos_names_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    storage_id?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** select columns of table "fungible_asset_activities" */
declare enum FungibleAssetActivitiesSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    AssetType = "asset_type",
    /** column name */
    BlockHeight = "block_height",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    GasFeePayerAddress = "gas_fee_payer_address",
    /** column name */
    IsFrozen = "is_frozen",
    /** column name */
    IsGasFee = "is_gas_fee",
    /** column name */
    IsTransactionSuccess = "is_transaction_success",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    StorageId = "storage_id",
    /** column name */
    StorageRefundAmount = "storage_refund_amount",
    /** column name */
    TokenStandard = "token_standard",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    Type = "type"
}
/** order by stddev() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesStddevOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by stddev_pop() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesStddevPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by stddev_samp() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesStddevSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "fungible_asset_activities" */
type FungibleAssetActivitiesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: FungibleAssetActivitiesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type FungibleAssetActivitiesStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    asset_type?: InputMaybe<Scalars["String"]["input"]>;
    block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    gas_fee_payer_address?: InputMaybe<Scalars["String"]["input"]>;
    is_frozen?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_gas_fee?: InputMaybe<Scalars["Boolean"]["input"]>;
    is_transaction_success?: InputMaybe<Scalars["Boolean"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    storage_id?: InputMaybe<Scalars["String"]["input"]>;
    storage_refund_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    type?: InputMaybe<Scalars["String"]["input"]>;
};
/** order by sum() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesSumOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by var_pop() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesVarPopOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by var_samp() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesVarSampOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** order by variance() on columns of table "fungible_asset_activities" */
type FungibleAssetActivitiesVarianceOrderBy = {
    amount?: InputMaybe<OrderBy>;
    block_height?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    storage_refund_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "fungible_asset_metadata" */
type FungibleAssetMetadata = {
    asset_type: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    decimals: Scalars["Int"]["output"];
    icon_uri?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp: Scalars["timestamp"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    name: Scalars["String"]["output"];
    project_uri?: Maybe<Scalars["String"]["output"]>;
    supply_aggregator_table_handle_v1?: Maybe<Scalars["String"]["output"]>;
    supply_aggregator_table_key_v1?: Maybe<Scalars["String"]["output"]>;
    symbol: Scalars["String"]["output"];
    token_standard: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "fungible_asset_metadata". All fields are combined with a logical 'AND'. */
type FungibleAssetMetadataBoolExp = {
    _and?: InputMaybe<Array<FungibleAssetMetadataBoolExp>>;
    _not?: InputMaybe<FungibleAssetMetadataBoolExp>;
    _or?: InputMaybe<Array<FungibleAssetMetadataBoolExp>>;
    asset_type?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    decimals?: InputMaybe<IntComparisonExp>;
    icon_uri?: InputMaybe<StringComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    project_uri?: InputMaybe<StringComparisonExp>;
    supply_aggregator_table_handle_v1?: InputMaybe<StringComparisonExp>;
    supply_aggregator_table_key_v1?: InputMaybe<StringComparisonExp>;
    symbol?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "fungible_asset_metadata". */
type FungibleAssetMetadataOrderBy = {
    asset_type?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    decimals?: InputMaybe<OrderBy>;
    icon_uri?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    project_uri?: InputMaybe<OrderBy>;
    supply_aggregator_table_handle_v1?: InputMaybe<OrderBy>;
    supply_aggregator_table_key_v1?: InputMaybe<OrderBy>;
    symbol?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "fungible_asset_metadata" */
declare enum FungibleAssetMetadataSelectColumn {
    /** column name */
    AssetType = "asset_type",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    Decimals = "decimals",
    /** column name */
    IconUri = "icon_uri",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Name = "name",
    /** column name */
    ProjectUri = "project_uri",
    /** column name */
    SupplyAggregatorTableHandleV1 = "supply_aggregator_table_handle_v1",
    /** column name */
    SupplyAggregatorTableKeyV1 = "supply_aggregator_table_key_v1",
    /** column name */
    Symbol = "symbol",
    /** column name */
    TokenStandard = "token_standard"
}
/** Streaming cursor of the table "fungible_asset_metadata" */
type FungibleAssetMetadataStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: FungibleAssetMetadataStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type FungibleAssetMetadataStreamCursorValueInput = {
    asset_type?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    decimals?: InputMaybe<Scalars["Int"]["input"]>;
    icon_uri?: InputMaybe<Scalars["String"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    project_uri?: InputMaybe<Scalars["String"]["input"]>;
    supply_aggregator_table_handle_v1?: InputMaybe<Scalars["String"]["input"]>;
    supply_aggregator_table_key_v1?: InputMaybe<Scalars["String"]["input"]>;
    symbol?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "indexer_status" */
type IndexerStatus = {
    db: Scalars["String"]["output"];
    is_indexer_up: Scalars["Boolean"]["output"];
};
/** Boolean expression to filter rows from the table "indexer_status". All fields are combined with a logical 'AND'. */
type IndexerStatusBoolExp = {
    _and?: InputMaybe<Array<IndexerStatusBoolExp>>;
    _not?: InputMaybe<IndexerStatusBoolExp>;
    _or?: InputMaybe<Array<IndexerStatusBoolExp>>;
    db?: InputMaybe<StringComparisonExp>;
    is_indexer_up?: InputMaybe<BooleanComparisonExp>;
};
/** Ordering options when selecting data from "indexer_status". */
type IndexerStatusOrderBy = {
    db?: InputMaybe<OrderBy>;
    is_indexer_up?: InputMaybe<OrderBy>;
};
/** select columns of table "indexer_status" */
declare enum IndexerStatusSelectColumn {
    /** column name */
    Db = "db",
    /** column name */
    IsIndexerUp = "is_indexer_up"
}
/** Streaming cursor of the table "indexer_status" */
type IndexerStatusStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: IndexerStatusStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type IndexerStatusStreamCursorValueInput = {
    db?: InputMaybe<Scalars["String"]["input"]>;
    is_indexer_up?: InputMaybe<Scalars["Boolean"]["input"]>;
};
type JsonbCastExp = {
    String?: InputMaybe<StringComparisonExp>;
};
/** Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'. */
type JsonbComparisonExp = {
    _cast?: InputMaybe<JsonbCastExp>;
    /** is the column contained in the given json value */
    _contained_in?: InputMaybe<Scalars["jsonb"]["input"]>;
    /** does the column contain the given json value at the top level */
    _contains?: InputMaybe<Scalars["jsonb"]["input"]>;
    _eq?: InputMaybe<Scalars["jsonb"]["input"]>;
    _gt?: InputMaybe<Scalars["jsonb"]["input"]>;
    _gte?: InputMaybe<Scalars["jsonb"]["input"]>;
    /** does the string exist as a top-level key in the column */
    _has_key?: InputMaybe<Scalars["String"]["input"]>;
    /** do all of these strings exist as top-level keys in the column */
    _has_keys_all?: InputMaybe<Array<Scalars["String"]["input"]>>;
    /** do any of these strings exist as top-level keys in the column */
    _has_keys_any?: InputMaybe<Array<Scalars["String"]["input"]>>;
    _in?: InputMaybe<Array<Scalars["jsonb"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["jsonb"]["input"]>;
    _lte?: InputMaybe<Scalars["jsonb"]["input"]>;
    _neq?: InputMaybe<Scalars["jsonb"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["jsonb"]["input"]>>;
};
/** columns and relationships of "ledger_infos" */
type LedgerInfos = {
    chain_id: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "ledger_infos". All fields are combined with a logical 'AND'. */
type LedgerInfosBoolExp = {
    _and?: InputMaybe<Array<LedgerInfosBoolExp>>;
    _not?: InputMaybe<LedgerInfosBoolExp>;
    _or?: InputMaybe<Array<LedgerInfosBoolExp>>;
    chain_id?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "ledger_infos". */
type LedgerInfosOrderBy = {
    chain_id?: InputMaybe<OrderBy>;
};
/** select columns of table "ledger_infos" */
declare enum LedgerInfosSelectColumn {
    /** column name */
    ChainId = "chain_id"
}
/** Streaming cursor of the table "ledger_infos" */
type LedgerInfosStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: LedgerInfosStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type LedgerInfosStreamCursorValueInput = {
    chain_id?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "move_resources" */
type MoveResources = {
    address: Scalars["String"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** aggregated selection of "move_resources" */
type MoveResourcesAggregate = {
    aggregate?: Maybe<MoveResourcesAggregateFields>;
    nodes: Array<MoveResources>;
};
/** aggregate fields of "move_resources" */
type MoveResourcesAggregateFields = {
    avg?: Maybe<MoveResourcesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<MoveResourcesMaxFields>;
    min?: Maybe<MoveResourcesMinFields>;
    stddev?: Maybe<MoveResourcesStddevFields>;
    stddev_pop?: Maybe<MoveResourcesStddevPopFields>;
    stddev_samp?: Maybe<MoveResourcesStddevSampFields>;
    sum?: Maybe<MoveResourcesSumFields>;
    var_pop?: Maybe<MoveResourcesVarPopFields>;
    var_samp?: Maybe<MoveResourcesVarSampFields>;
    variance?: Maybe<MoveResourcesVarianceFields>;
};
/** aggregate fields of "move_resources" */
type MoveResourcesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<MoveResourcesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type MoveResourcesAvgFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "move_resources". All fields are combined with a logical 'AND'. */
type MoveResourcesBoolExp = {
    _and?: InputMaybe<Array<MoveResourcesBoolExp>>;
    _not?: InputMaybe<MoveResourcesBoolExp>;
    _or?: InputMaybe<Array<MoveResourcesBoolExp>>;
    address?: InputMaybe<StringComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** aggregate max on columns */
type MoveResourcesMaxFields = {
    address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate min on columns */
type MoveResourcesMinFields = {
    address?: Maybe<Scalars["String"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** Ordering options when selecting data from "move_resources". */
type MoveResourcesOrderBy = {
    address?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "move_resources" */
declare enum MoveResourcesSelectColumn {
    /** column name */
    Address = "address",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** aggregate stddev on columns */
type MoveResourcesStddevFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type MoveResourcesStddevPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type MoveResourcesStddevSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "move_resources" */
type MoveResourcesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: MoveResourcesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type MoveResourcesStreamCursorValueInput = {
    address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** aggregate sum on columns */
type MoveResourcesSumFields = {
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type MoveResourcesVarPopFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type MoveResourcesVarSampFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type MoveResourcesVarianceFields = {
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "nft_marketplace_v2.current_nft_marketplace_auctions" */
type NftMarketplaceV2CurrentNftMarketplaceAuctions = {
    buy_it_now_price?: Maybe<Scalars["numeric"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id: Scalars["String"]["output"];
    contract_address: Scalars["String"]["output"];
    current_bid_price?: Maybe<Scalars["numeric"]["output"]>;
    current_bidder?: Maybe<Scalars["String"]["output"]>;
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatasV2>;
    entry_function_id_str: Scalars["String"]["output"];
    expiration_time: Scalars["numeric"]["output"];
    fee_schedule_id: Scalars["String"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    last_transaction_timestamp: Scalars["timestamptz"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    listing_id: Scalars["String"]["output"];
    marketplace: Scalars["String"]["output"];
    seller: Scalars["String"]["output"];
    starting_bid_price: Scalars["numeric"]["output"];
    token_amount: Scalars["numeric"]["output"];
    token_data_id: Scalars["String"]["output"];
    token_standard: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "nft_marketplace_v2.current_nft_marketplace_auctions". All fields are combined with a logical 'AND'. */
type NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp = {
    _and?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp>>;
    _not?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp>;
    _or?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp>>;
    buy_it_now_price?: InputMaybe<NumericComparisonExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    contract_address?: InputMaybe<StringComparisonExp>;
    current_bid_price?: InputMaybe<NumericComparisonExp>;
    current_bidder?: InputMaybe<StringComparisonExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    expiration_time?: InputMaybe<NumericComparisonExp>;
    fee_schedule_id?: InputMaybe<StringComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestamptzComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    listing_id?: InputMaybe<StringComparisonExp>;
    marketplace?: InputMaybe<StringComparisonExp>;
    seller?: InputMaybe<StringComparisonExp>;
    starting_bid_price?: InputMaybe<NumericComparisonExp>;
    token_amount?: InputMaybe<NumericComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "nft_marketplace_v2.current_nft_marketplace_auctions". */
type NftMarketplaceV2CurrentNftMarketplaceAuctionsOrderBy = {
    buy_it_now_price?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    contract_address?: InputMaybe<OrderBy>;
    current_bid_price?: InputMaybe<OrderBy>;
    current_bidder?: InputMaybe<OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    expiration_time?: InputMaybe<OrderBy>;
    fee_schedule_id?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    listing_id?: InputMaybe<OrderBy>;
    marketplace?: InputMaybe<OrderBy>;
    seller?: InputMaybe<OrderBy>;
    starting_bid_price?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "nft_marketplace_v2.current_nft_marketplace_auctions" */
declare enum NftMarketplaceV2CurrentNftMarketplaceAuctionsSelectColumn {
    /** column name */
    BuyItNowPrice = "buy_it_now_price",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    ContractAddress = "contract_address",
    /** column name */
    CurrentBidPrice = "current_bid_price",
    /** column name */
    CurrentBidder = "current_bidder",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    ExpirationTime = "expiration_time",
    /** column name */
    FeeScheduleId = "fee_schedule_id",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    ListingId = "listing_id",
    /** column name */
    Marketplace = "marketplace",
    /** column name */
    Seller = "seller",
    /** column name */
    StartingBidPrice = "starting_bid_price",
    /** column name */
    TokenAmount = "token_amount",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenStandard = "token_standard"
}
/** Streaming cursor of the table "nft_marketplace_v2_current_nft_marketplace_auctions" */
type NftMarketplaceV2CurrentNftMarketplaceAuctionsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NftMarketplaceV2CurrentNftMarketplaceAuctionsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NftMarketplaceV2CurrentNftMarketplaceAuctionsStreamCursorValueInput = {
    buy_it_now_price?: InputMaybe<Scalars["numeric"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    contract_address?: InputMaybe<Scalars["String"]["input"]>;
    current_bid_price?: InputMaybe<Scalars["numeric"]["input"]>;
    current_bidder?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    expiration_time?: InputMaybe<Scalars["numeric"]["input"]>;
    fee_schedule_id?: InputMaybe<Scalars["String"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    listing_id?: InputMaybe<Scalars["String"]["input"]>;
    marketplace?: InputMaybe<Scalars["String"]["input"]>;
    seller?: InputMaybe<Scalars["String"]["input"]>;
    starting_bid_price?: InputMaybe<Scalars["numeric"]["input"]>;
    token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "nft_marketplace_v2.current_nft_marketplace_collection_offers" */
type NftMarketplaceV2CurrentNftMarketplaceCollectionOffers = {
    buyer: Scalars["String"]["output"];
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id: Scalars["String"]["output"];
    collection_offer_id: Scalars["String"]["output"];
    contract_address: Scalars["String"]["output"];
    /** An object relationship */
    current_collection_v2?: Maybe<CurrentCollectionsV2>;
    entry_function_id_str: Scalars["String"]["output"];
    expiration_time: Scalars["numeric"]["output"];
    fee_schedule_id: Scalars["String"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    item_price: Scalars["numeric"]["output"];
    last_transaction_timestamp: Scalars["timestamptz"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    marketplace: Scalars["String"]["output"];
    remaining_token_amount: Scalars["numeric"]["output"];
    token_standard: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "nft_marketplace_v2.current_nft_marketplace_collection_offers". All fields are combined with a logical 'AND'. */
type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp = {
    _and?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp>>;
    _not?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp>;
    _or?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp>>;
    buyer?: InputMaybe<StringComparisonExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    collection_offer_id?: InputMaybe<StringComparisonExp>;
    contract_address?: InputMaybe<StringComparisonExp>;
    current_collection_v2?: InputMaybe<CurrentCollectionsV2BoolExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    expiration_time?: InputMaybe<NumericComparisonExp>;
    fee_schedule_id?: InputMaybe<StringComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    item_price?: InputMaybe<NumericComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestamptzComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    marketplace?: InputMaybe<StringComparisonExp>;
    remaining_token_amount?: InputMaybe<NumericComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "nft_marketplace_v2.current_nft_marketplace_collection_offers". */
type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersOrderBy = {
    buyer?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    collection_offer_id?: InputMaybe<OrderBy>;
    contract_address?: InputMaybe<OrderBy>;
    current_collection_v2?: InputMaybe<CurrentCollectionsV2OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    expiration_time?: InputMaybe<OrderBy>;
    fee_schedule_id?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    item_price?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    marketplace?: InputMaybe<OrderBy>;
    remaining_token_amount?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "nft_marketplace_v2.current_nft_marketplace_collection_offers" */
declare enum NftMarketplaceV2CurrentNftMarketplaceCollectionOffersSelectColumn {
    /** column name */
    Buyer = "buyer",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    CollectionOfferId = "collection_offer_id",
    /** column name */
    ContractAddress = "contract_address",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    ExpirationTime = "expiration_time",
    /** column name */
    FeeScheduleId = "fee_schedule_id",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    ItemPrice = "item_price",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Marketplace = "marketplace",
    /** column name */
    RemainingTokenAmount = "remaining_token_amount",
    /** column name */
    TokenStandard = "token_standard"
}
/** Streaming cursor of the table "nft_marketplace_v2_current_nft_marketplace_collection_offers" */
type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamCursorValueInput = {
    buyer?: InputMaybe<Scalars["String"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    collection_offer_id?: InputMaybe<Scalars["String"]["input"]>;
    contract_address?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    expiration_time?: InputMaybe<Scalars["numeric"]["input"]>;
    fee_schedule_id?: InputMaybe<Scalars["String"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    item_price?: InputMaybe<Scalars["numeric"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    marketplace?: InputMaybe<Scalars["String"]["input"]>;
    remaining_token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "nft_marketplace_v2.current_nft_marketplace_listings" */
type NftMarketplaceV2CurrentNftMarketplaceListings = {
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id: Scalars["String"]["output"];
    contract_address: Scalars["String"]["output"];
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatasV2>;
    entry_function_id_str: Scalars["String"]["output"];
    fee_schedule_id: Scalars["String"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    last_transaction_timestamp: Scalars["timestamptz"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    listing_id: Scalars["String"]["output"];
    marketplace: Scalars["String"]["output"];
    price: Scalars["numeric"]["output"];
    seller: Scalars["String"]["output"];
    token_amount: Scalars["numeric"]["output"];
    token_data_id: Scalars["String"]["output"];
    token_standard: Scalars["String"]["output"];
};
/** aggregated selection of "nft_marketplace_v2.current_nft_marketplace_listings" */
type NftMarketplaceV2CurrentNftMarketplaceListingsAggregate = {
    aggregate?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsAggregateFields>;
    nodes: Array<NftMarketplaceV2CurrentNftMarketplaceListings>;
};
/** aggregate fields of "nft_marketplace_v2.current_nft_marketplace_listings" */
type NftMarketplaceV2CurrentNftMarketplaceListingsAggregateFields = {
    avg?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsMaxFields>;
    min?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsMinFields>;
    stddev?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsStddevFields>;
    stddev_pop?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsStddevPopFields>;
    stddev_samp?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsStddevSampFields>;
    sum?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsSumFields>;
    var_pop?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsVarPopFields>;
    var_samp?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsVarSampFields>;
    variance?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListingsVarianceFields>;
};
/** aggregate fields of "nft_marketplace_v2.current_nft_marketplace_listings" */
type NftMarketplaceV2CurrentNftMarketplaceListingsAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsAvgFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "nft_marketplace_v2.current_nft_marketplace_listings". All fields are combined with a logical 'AND'. */
type NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp = {
    _and?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>>;
    _not?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>;
    _or?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>>;
    coin_type?: InputMaybe<StringComparisonExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    contract_address?: InputMaybe<StringComparisonExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    fee_schedule_id?: InputMaybe<StringComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestamptzComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    listing_id?: InputMaybe<StringComparisonExp>;
    marketplace?: InputMaybe<StringComparisonExp>;
    price?: InputMaybe<NumericComparisonExp>;
    seller?: InputMaybe<StringComparisonExp>;
    token_amount?: InputMaybe<NumericComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsMaxFields = {
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id?: Maybe<Scalars["String"]["output"]>;
    contract_address?: Maybe<Scalars["String"]["output"]>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    fee_schedule_id?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    listing_id?: Maybe<Scalars["String"]["output"]>;
    marketplace?: Maybe<Scalars["String"]["output"]>;
    price?: Maybe<Scalars["numeric"]["output"]>;
    seller?: Maybe<Scalars["String"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** aggregate min on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsMinFields = {
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id?: Maybe<Scalars["String"]["output"]>;
    contract_address?: Maybe<Scalars["String"]["output"]>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    fee_schedule_id?: Maybe<Scalars["String"]["output"]>;
    last_transaction_timestamp?: Maybe<Scalars["timestamptz"]["output"]>;
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    listing_id?: Maybe<Scalars["String"]["output"]>;
    marketplace?: Maybe<Scalars["String"]["output"]>;
    price?: Maybe<Scalars["numeric"]["output"]>;
    seller?: Maybe<Scalars["String"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
};
/** Ordering options when selecting data from "nft_marketplace_v2.current_nft_marketplace_listings". */
type NftMarketplaceV2CurrentNftMarketplaceListingsOrderBy = {
    coin_type?: InputMaybe<OrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    contract_address?: InputMaybe<OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    fee_schedule_id?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    listing_id?: InputMaybe<OrderBy>;
    marketplace?: InputMaybe<OrderBy>;
    price?: InputMaybe<OrderBy>;
    seller?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "nft_marketplace_v2.current_nft_marketplace_listings" */
declare enum NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn {
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    ContractAddress = "contract_address",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    FeeScheduleId = "fee_schedule_id",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    ListingId = "listing_id",
    /** column name */
    Marketplace = "marketplace",
    /** column name */
    Price = "price",
    /** column name */
    Seller = "seller",
    /** column name */
    TokenAmount = "token_amount",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenStandard = "token_standard"
}
/** aggregate stddev on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsStddevFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsStddevPopFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsStddevSampFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "nft_marketplace_v2_current_nft_marketplace_listings" */
type NftMarketplaceV2CurrentNftMarketplaceListingsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NftMarketplaceV2CurrentNftMarketplaceListingsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NftMarketplaceV2CurrentNftMarketplaceListingsStreamCursorValueInput = {
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    contract_address?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    fee_schedule_id?: InputMaybe<Scalars["String"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    listing_id?: InputMaybe<Scalars["String"]["input"]>;
    marketplace?: InputMaybe<Scalars["String"]["input"]>;
    price?: InputMaybe<Scalars["numeric"]["input"]>;
    seller?: InputMaybe<Scalars["String"]["input"]>;
    token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsSumFields = {
    last_transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    price?: Maybe<Scalars["numeric"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
};
/** aggregate var_pop on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsVarPopFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsVarSampFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type NftMarketplaceV2CurrentNftMarketplaceListingsVarianceFields = {
    last_transaction_version?: Maybe<Scalars["Float"]["output"]>;
    price?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
};
/** columns and relationships of "nft_marketplace_v2.current_nft_marketplace_token_offers" */
type NftMarketplaceV2CurrentNftMarketplaceTokenOffers = {
    buyer: Scalars["String"]["output"];
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id: Scalars["String"]["output"];
    contract_address: Scalars["String"]["output"];
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatasV2>;
    entry_function_id_str: Scalars["String"]["output"];
    expiration_time: Scalars["numeric"]["output"];
    fee_schedule_id: Scalars["String"]["output"];
    is_deleted: Scalars["Boolean"]["output"];
    last_transaction_timestamp: Scalars["timestamptz"]["output"];
    last_transaction_version: Scalars["bigint"]["output"];
    marketplace: Scalars["String"]["output"];
    offer_id: Scalars["String"]["output"];
    price: Scalars["numeric"]["output"];
    token_amount: Scalars["numeric"]["output"];
    token_data_id: Scalars["String"]["output"];
    token_standard: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "nft_marketplace_v2.current_nft_marketplace_token_offers". All fields are combined with a logical 'AND'. */
type NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp = {
    _and?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp>>;
    _not?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp>;
    _or?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp>>;
    buyer?: InputMaybe<StringComparisonExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    contract_address?: InputMaybe<StringComparisonExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    expiration_time?: InputMaybe<NumericComparisonExp>;
    fee_schedule_id?: InputMaybe<StringComparisonExp>;
    is_deleted?: InputMaybe<BooleanComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestamptzComparisonExp>;
    last_transaction_version?: InputMaybe<BigintComparisonExp>;
    marketplace?: InputMaybe<StringComparisonExp>;
    offer_id?: InputMaybe<StringComparisonExp>;
    price?: InputMaybe<NumericComparisonExp>;
    token_amount?: InputMaybe<NumericComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "nft_marketplace_v2.current_nft_marketplace_token_offers". */
type NftMarketplaceV2CurrentNftMarketplaceTokenOffersOrderBy = {
    buyer?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    contract_address?: InputMaybe<OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    expiration_time?: InputMaybe<OrderBy>;
    fee_schedule_id?: InputMaybe<OrderBy>;
    is_deleted?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_transaction_version?: InputMaybe<OrderBy>;
    marketplace?: InputMaybe<OrderBy>;
    offer_id?: InputMaybe<OrderBy>;
    price?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
};
/** select columns of table "nft_marketplace_v2.current_nft_marketplace_token_offers" */
declare enum NftMarketplaceV2CurrentNftMarketplaceTokenOffersSelectColumn {
    /** column name */
    Buyer = "buyer",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    ContractAddress = "contract_address",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    ExpirationTime = "expiration_time",
    /** column name */
    FeeScheduleId = "fee_schedule_id",
    /** column name */
    IsDeleted = "is_deleted",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastTransactionVersion = "last_transaction_version",
    /** column name */
    Marketplace = "marketplace",
    /** column name */
    OfferId = "offer_id",
    /** column name */
    Price = "price",
    /** column name */
    TokenAmount = "token_amount",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenStandard = "token_standard"
}
/** Streaming cursor of the table "nft_marketplace_v2_current_nft_marketplace_token_offers" */
type NftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamCursorValueInput = {
    buyer?: InputMaybe<Scalars["String"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    contract_address?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    expiration_time?: InputMaybe<Scalars["numeric"]["input"]>;
    fee_schedule_id?: InputMaybe<Scalars["String"]["input"]>;
    is_deleted?: InputMaybe<Scalars["Boolean"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
    last_transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    marketplace?: InputMaybe<Scalars["String"]["input"]>;
    offer_id?: InputMaybe<Scalars["String"]["input"]>;
    price?: InputMaybe<Scalars["numeric"]["input"]>;
    token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "nft_marketplace_v2.nft_marketplace_activities" */
type NftMarketplaceV2NftMarketplaceActivities = {
    buyer?: Maybe<Scalars["String"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_id: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    contract_address: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatasV2>;
    entry_function_id_str: Scalars["String"]["output"];
    event_index: Scalars["bigint"]["output"];
    event_type: Scalars["String"]["output"];
    fee_schedule_id: Scalars["String"]["output"];
    marketplace: Scalars["String"]["output"];
    offer_or_listing_id: Scalars["String"]["output"];
    price: Scalars["numeric"]["output"];
    property_version?: Maybe<Scalars["String"]["output"]>;
    seller?: Maybe<Scalars["String"]["output"]>;
    token_amount: Scalars["numeric"]["output"];
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_name?: Maybe<Scalars["String"]["output"]>;
    token_standard: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamptz"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "nft_marketplace_v2.nft_marketplace_activities". All fields are combined with a logical 'AND'. */
type NftMarketplaceV2NftMarketplaceActivitiesBoolExp = {
    _and?: InputMaybe<Array<NftMarketplaceV2NftMarketplaceActivitiesBoolExp>>;
    _not?: InputMaybe<NftMarketplaceV2NftMarketplaceActivitiesBoolExp>;
    _or?: InputMaybe<Array<NftMarketplaceV2NftMarketplaceActivitiesBoolExp>>;
    buyer?: InputMaybe<StringComparisonExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    collection_id?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    contract_address?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    event_type?: InputMaybe<StringComparisonExp>;
    fee_schedule_id?: InputMaybe<StringComparisonExp>;
    marketplace?: InputMaybe<StringComparisonExp>;
    offer_or_listing_id?: InputMaybe<StringComparisonExp>;
    price?: InputMaybe<NumericComparisonExp>;
    property_version?: InputMaybe<StringComparisonExp>;
    seller?: InputMaybe<StringComparisonExp>;
    token_amount?: InputMaybe<NumericComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_name?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestamptzComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "nft_marketplace_v2.nft_marketplace_activities". */
type NftMarketplaceV2NftMarketplaceActivitiesOrderBy = {
    buyer?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_id?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    contract_address?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_type?: InputMaybe<OrderBy>;
    fee_schedule_id?: InputMaybe<OrderBy>;
    marketplace?: InputMaybe<OrderBy>;
    offer_or_listing_id?: InputMaybe<OrderBy>;
    price?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    seller?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_name?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "nft_marketplace_v2.nft_marketplace_activities" */
declare enum NftMarketplaceV2NftMarketplaceActivitiesSelectColumn {
    /** column name */
    Buyer = "buyer",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CollectionId = "collection_id",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    ContractAddress = "contract_address",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    EventType = "event_type",
    /** column name */
    FeeScheduleId = "fee_schedule_id",
    /** column name */
    Marketplace = "marketplace",
    /** column name */
    OfferOrListingId = "offer_or_listing_id",
    /** column name */
    Price = "price",
    /** column name */
    PropertyVersion = "property_version",
    /** column name */
    Seller = "seller",
    /** column name */
    TokenAmount = "token_amount",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenName = "token_name",
    /** column name */
    TokenStandard = "token_standard",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** Streaming cursor of the table "nft_marketplace_v2_nft_marketplace_activities" */
type NftMarketplaceV2NftMarketplaceActivitiesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NftMarketplaceV2NftMarketplaceActivitiesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NftMarketplaceV2NftMarketplaceActivitiesStreamCursorValueInput = {
    buyer?: InputMaybe<Scalars["String"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    collection_id?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    contract_address?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    event_type?: InputMaybe<Scalars["String"]["input"]>;
    fee_schedule_id?: InputMaybe<Scalars["String"]["input"]>;
    marketplace?: InputMaybe<Scalars["String"]["input"]>;
    offer_or_listing_id?: InputMaybe<Scalars["String"]["input"]>;
    price?: InputMaybe<Scalars["numeric"]["input"]>;
    property_version?: InputMaybe<Scalars["String"]["input"]>;
    seller?: InputMaybe<Scalars["String"]["input"]>;
    token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_name?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamptz"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "nft_metadata_crawler.parsed_asset_uris" */
type NftMetadataCrawlerParsedAssetUris = {
    animation_optimizer_retry_count: Scalars["Int"]["output"];
    asset_uri: Scalars["String"]["output"];
    cdn_animation_uri?: Maybe<Scalars["String"]["output"]>;
    cdn_image_uri?: Maybe<Scalars["String"]["output"]>;
    cdn_json_uri?: Maybe<Scalars["String"]["output"]>;
    image_optimizer_retry_count: Scalars["Int"]["output"];
    json_parser_retry_count: Scalars["Int"]["output"];
    raw_animation_uri?: Maybe<Scalars["String"]["output"]>;
    raw_image_uri?: Maybe<Scalars["String"]["output"]>;
};
/** Boolean expression to filter rows from the table "nft_metadata_crawler.parsed_asset_uris". All fields are combined with a logical 'AND'. */
type NftMetadataCrawlerParsedAssetUrisBoolExp = {
    _and?: InputMaybe<Array<NftMetadataCrawlerParsedAssetUrisBoolExp>>;
    _not?: InputMaybe<NftMetadataCrawlerParsedAssetUrisBoolExp>;
    _or?: InputMaybe<Array<NftMetadataCrawlerParsedAssetUrisBoolExp>>;
    animation_optimizer_retry_count?: InputMaybe<IntComparisonExp>;
    asset_uri?: InputMaybe<StringComparisonExp>;
    cdn_animation_uri?: InputMaybe<StringComparisonExp>;
    cdn_image_uri?: InputMaybe<StringComparisonExp>;
    cdn_json_uri?: InputMaybe<StringComparisonExp>;
    image_optimizer_retry_count?: InputMaybe<IntComparisonExp>;
    json_parser_retry_count?: InputMaybe<IntComparisonExp>;
    raw_animation_uri?: InputMaybe<StringComparisonExp>;
    raw_image_uri?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "nft_metadata_crawler.parsed_asset_uris". */
type NftMetadataCrawlerParsedAssetUrisOrderBy = {
    animation_optimizer_retry_count?: InputMaybe<OrderBy>;
    asset_uri?: InputMaybe<OrderBy>;
    cdn_animation_uri?: InputMaybe<OrderBy>;
    cdn_image_uri?: InputMaybe<OrderBy>;
    cdn_json_uri?: InputMaybe<OrderBy>;
    image_optimizer_retry_count?: InputMaybe<OrderBy>;
    json_parser_retry_count?: InputMaybe<OrderBy>;
    raw_animation_uri?: InputMaybe<OrderBy>;
    raw_image_uri?: InputMaybe<OrderBy>;
};
/** select columns of table "nft_metadata_crawler.parsed_asset_uris" */
declare enum NftMetadataCrawlerParsedAssetUrisSelectColumn {
    /** column name */
    AnimationOptimizerRetryCount = "animation_optimizer_retry_count",
    /** column name */
    AssetUri = "asset_uri",
    /** column name */
    CdnAnimationUri = "cdn_animation_uri",
    /** column name */
    CdnImageUri = "cdn_image_uri",
    /** column name */
    CdnJsonUri = "cdn_json_uri",
    /** column name */
    ImageOptimizerRetryCount = "image_optimizer_retry_count",
    /** column name */
    JsonParserRetryCount = "json_parser_retry_count",
    /** column name */
    RawAnimationUri = "raw_animation_uri",
    /** column name */
    RawImageUri = "raw_image_uri"
}
/** Streaming cursor of the table "nft_metadata_crawler_parsed_asset_uris" */
type NftMetadataCrawlerParsedAssetUrisStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NftMetadataCrawlerParsedAssetUrisStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NftMetadataCrawlerParsedAssetUrisStreamCursorValueInput = {
    animation_optimizer_retry_count?: InputMaybe<Scalars["Int"]["input"]>;
    asset_uri?: InputMaybe<Scalars["String"]["input"]>;
    cdn_animation_uri?: InputMaybe<Scalars["String"]["input"]>;
    cdn_image_uri?: InputMaybe<Scalars["String"]["input"]>;
    cdn_json_uri?: InputMaybe<Scalars["String"]["input"]>;
    image_optimizer_retry_count?: InputMaybe<Scalars["Int"]["input"]>;
    json_parser_retry_count?: InputMaybe<Scalars["Int"]["input"]>;
    raw_animation_uri?: InputMaybe<Scalars["String"]["input"]>;
    raw_image_uri?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "num_active_delegator_per_pool" */
type NumActiveDelegatorPerPool = {
    num_active_delegator?: Maybe<Scalars["bigint"]["output"]>;
    pool_address?: Maybe<Scalars["String"]["output"]>;
};
/** Boolean expression to filter rows from the table "num_active_delegator_per_pool". All fields are combined with a logical 'AND'. */
type NumActiveDelegatorPerPoolBoolExp = {
    _and?: InputMaybe<Array<NumActiveDelegatorPerPoolBoolExp>>;
    _not?: InputMaybe<NumActiveDelegatorPerPoolBoolExp>;
    _or?: InputMaybe<Array<NumActiveDelegatorPerPoolBoolExp>>;
    num_active_delegator?: InputMaybe<BigintComparisonExp>;
    pool_address?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "num_active_delegator_per_pool". */
type NumActiveDelegatorPerPoolOrderBy = {
    num_active_delegator?: InputMaybe<OrderBy>;
    pool_address?: InputMaybe<OrderBy>;
};
/** select columns of table "num_active_delegator_per_pool" */
declare enum NumActiveDelegatorPerPoolSelectColumn {
    /** column name */
    NumActiveDelegator = "num_active_delegator",
    /** column name */
    PoolAddress = "pool_address"
}
/** Streaming cursor of the table "num_active_delegator_per_pool" */
type NumActiveDelegatorPerPoolStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: NumActiveDelegatorPerPoolStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type NumActiveDelegatorPerPoolStreamCursorValueInput = {
    num_active_delegator?: InputMaybe<Scalars["bigint"]["input"]>;
    pool_address?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to compare columns of type "numeric". All fields are combined with logical 'AND'. */
type NumericComparisonExp = {
    _eq?: InputMaybe<Scalars["numeric"]["input"]>;
    _gt?: InputMaybe<Scalars["numeric"]["input"]>;
    _gte?: InputMaybe<Scalars["numeric"]["input"]>;
    _in?: InputMaybe<Array<Scalars["numeric"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["numeric"]["input"]>;
    _lte?: InputMaybe<Scalars["numeric"]["input"]>;
    _neq?: InputMaybe<Scalars["numeric"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["numeric"]["input"]>>;
};
/** column ordering options */
declare enum OrderBy {
    /** in ascending order, nulls last */
    Asc = "asc",
    /** in ascending order, nulls first */
    AscNullsFirst = "asc_nulls_first",
    /** in ascending order, nulls last */
    AscNullsLast = "asc_nulls_last",
    /** in descending order, nulls first */
    Desc = "desc",
    /** in descending order, nulls first */
    DescNullsFirst = "desc_nulls_first",
    /** in descending order, nulls last */
    DescNullsLast = "desc_nulls_last"
}
/** columns and relationships of "processor_status" */
type ProcessorStatus = {
    last_success_version: Scalars["bigint"]["output"];
    last_transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    last_updated: Scalars["timestamp"]["output"];
    processor: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "processor_status". All fields are combined with a logical 'AND'. */
type ProcessorStatusBoolExp = {
    _and?: InputMaybe<Array<ProcessorStatusBoolExp>>;
    _not?: InputMaybe<ProcessorStatusBoolExp>;
    _or?: InputMaybe<Array<ProcessorStatusBoolExp>>;
    last_success_version?: InputMaybe<BigintComparisonExp>;
    last_transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    last_updated?: InputMaybe<TimestampComparisonExp>;
    processor?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "processor_status". */
type ProcessorStatusOrderBy = {
    last_success_version?: InputMaybe<OrderBy>;
    last_transaction_timestamp?: InputMaybe<OrderBy>;
    last_updated?: InputMaybe<OrderBy>;
    processor?: InputMaybe<OrderBy>;
};
/** select columns of table "processor_status" */
declare enum ProcessorStatusSelectColumn {
    /** column name */
    LastSuccessVersion = "last_success_version",
    /** column name */
    LastTransactionTimestamp = "last_transaction_timestamp",
    /** column name */
    LastUpdated = "last_updated",
    /** column name */
    Processor = "processor"
}
/** Streaming cursor of the table "processor_status" */
type ProcessorStatusStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: ProcessorStatusStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type ProcessorStatusStreamCursorValueInput = {
    last_success_version?: InputMaybe<Scalars["bigint"]["input"]>;
    last_transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    last_updated?: InputMaybe<Scalars["timestamp"]["input"]>;
    processor?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "proposal_votes" */
type ProposalVotes = {
    num_votes: Scalars["numeric"]["output"];
    proposal_id: Scalars["bigint"]["output"];
    should_pass: Scalars["Boolean"]["output"];
    staking_pool_address: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    voter_address: Scalars["String"]["output"];
};
/** aggregated selection of "proposal_votes" */
type ProposalVotesAggregate = {
    aggregate?: Maybe<ProposalVotesAggregateFields>;
    nodes: Array<ProposalVotes>;
};
/** aggregate fields of "proposal_votes" */
type ProposalVotesAggregateFields = {
    avg?: Maybe<ProposalVotesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<ProposalVotesMaxFields>;
    min?: Maybe<ProposalVotesMinFields>;
    stddev?: Maybe<ProposalVotesStddevFields>;
    stddev_pop?: Maybe<ProposalVotesStddevPopFields>;
    stddev_samp?: Maybe<ProposalVotesStddevSampFields>;
    sum?: Maybe<ProposalVotesSumFields>;
    var_pop?: Maybe<ProposalVotesVarPopFields>;
    var_samp?: Maybe<ProposalVotesVarSampFields>;
    variance?: Maybe<ProposalVotesVarianceFields>;
};
/** aggregate fields of "proposal_votes" */
type ProposalVotesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<ProposalVotesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** aggregate avg on columns */
type ProposalVotesAvgFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Boolean expression to filter rows from the table "proposal_votes". All fields are combined with a logical 'AND'. */
type ProposalVotesBoolExp = {
    _and?: InputMaybe<Array<ProposalVotesBoolExp>>;
    _not?: InputMaybe<ProposalVotesBoolExp>;
    _or?: InputMaybe<Array<ProposalVotesBoolExp>>;
    num_votes?: InputMaybe<NumericComparisonExp>;
    proposal_id?: InputMaybe<BigintComparisonExp>;
    should_pass?: InputMaybe<BooleanComparisonExp>;
    staking_pool_address?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    voter_address?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type ProposalVotesMaxFields = {
    num_votes?: Maybe<Scalars["numeric"]["output"]>;
    proposal_id?: Maybe<Scalars["bigint"]["output"]>;
    staking_pool_address?: Maybe<Scalars["String"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    voter_address?: Maybe<Scalars["String"]["output"]>;
};
/** aggregate min on columns */
type ProposalVotesMinFields = {
    num_votes?: Maybe<Scalars["numeric"]["output"]>;
    proposal_id?: Maybe<Scalars["bigint"]["output"]>;
    staking_pool_address?: Maybe<Scalars["String"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    voter_address?: Maybe<Scalars["String"]["output"]>;
};
/** Ordering options when selecting data from "proposal_votes". */
type ProposalVotesOrderBy = {
    num_votes?: InputMaybe<OrderBy>;
    proposal_id?: InputMaybe<OrderBy>;
    should_pass?: InputMaybe<OrderBy>;
    staking_pool_address?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    voter_address?: InputMaybe<OrderBy>;
};
/** select columns of table "proposal_votes" */
declare enum ProposalVotesSelectColumn {
    /** column name */
    NumVotes = "num_votes",
    /** column name */
    ProposalId = "proposal_id",
    /** column name */
    ShouldPass = "should_pass",
    /** column name */
    StakingPoolAddress = "staking_pool_address",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    VoterAddress = "voter_address"
}
/** aggregate stddev on columns */
type ProposalVotesStddevFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_pop on columns */
type ProposalVotesStddevPopFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate stddev_samp on columns */
type ProposalVotesStddevSampFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** Streaming cursor of the table "proposal_votes" */
type ProposalVotesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: ProposalVotesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type ProposalVotesStreamCursorValueInput = {
    num_votes?: InputMaybe<Scalars["numeric"]["input"]>;
    proposal_id?: InputMaybe<Scalars["bigint"]["input"]>;
    should_pass?: InputMaybe<Scalars["Boolean"]["input"]>;
    staking_pool_address?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    voter_address?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type ProposalVotesSumFields = {
    num_votes?: Maybe<Scalars["numeric"]["output"]>;
    proposal_id?: Maybe<Scalars["bigint"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** aggregate var_pop on columns */
type ProposalVotesVarPopFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate var_samp on columns */
type ProposalVotesVarSampFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** aggregate variance on columns */
type ProposalVotesVarianceFields = {
    num_votes?: Maybe<Scalars["Float"]["output"]>;
    proposal_id?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
type QueryRoot = {
    /** fetch data from the table: "account_transactions" */
    account_transactions: Array<AccountTransactions>;
    /** fetch aggregated fields from the table: "account_transactions" */
    account_transactions_aggregate: AccountTransactionsAggregate;
    /** fetch data from the table: "account_transactions" using primary key columns */
    account_transactions_by_pk?: Maybe<AccountTransactions>;
    /** fetch data from the table: "address_events_summary" */
    address_events_summary: Array<AddressEventsSummary>;
    /** fetch data from the table: "address_version_from_events" */
    address_version_from_events: Array<AddressVersionFromEvents>;
    /** fetch aggregated fields from the table: "address_version_from_events" */
    address_version_from_events_aggregate: AddressVersionFromEventsAggregate;
    /** fetch data from the table: "address_version_from_move_resources" */
    address_version_from_move_resources: Array<AddressVersionFromMoveResources>;
    /** fetch aggregated fields from the table: "address_version_from_move_resources" */
    address_version_from_move_resources_aggregate: AddressVersionFromMoveResourcesAggregate;
    /** fetch data from the table: "block_metadata_transactions" */
    block_metadata_transactions: Array<BlockMetadataTransactions>;
    /** fetch data from the table: "block_metadata_transactions" using primary key columns */
    block_metadata_transactions_by_pk?: Maybe<BlockMetadataTransactions>;
    /** An array relationship */
    coin_activities: Array<CoinActivities>;
    /** An aggregate relationship */
    coin_activities_aggregate: CoinActivitiesAggregate;
    /** fetch data from the table: "coin_activities" using primary key columns */
    coin_activities_by_pk?: Maybe<CoinActivities>;
    /** fetch data from the table: "coin_balances" */
    coin_balances: Array<CoinBalances>;
    /** fetch data from the table: "coin_balances" using primary key columns */
    coin_balances_by_pk?: Maybe<CoinBalances>;
    /** fetch data from the table: "coin_infos" */
    coin_infos: Array<CoinInfos>;
    /** fetch data from the table: "coin_infos" using primary key columns */
    coin_infos_by_pk?: Maybe<CoinInfos>;
    /** fetch data from the table: "coin_supply" */
    coin_supply: Array<CoinSupply>;
    /** fetch data from the table: "coin_supply" using primary key columns */
    coin_supply_by_pk?: Maybe<CoinSupply>;
    /** fetch data from the table: "collection_datas" */
    collection_datas: Array<CollectionDatas>;
    /** fetch data from the table: "collection_datas" using primary key columns */
    collection_datas_by_pk?: Maybe<CollectionDatas>;
    /** fetch data from the table: "current_ans_lookup" */
    current_ans_lookup: Array<CurrentAnsLookup>;
    /** fetch data from the table: "current_ans_lookup" using primary key columns */
    current_ans_lookup_by_pk?: Maybe<CurrentAnsLookup>;
    /** fetch data from the table: "current_ans_lookup_v2" */
    current_ans_lookup_v2: Array<CurrentAnsLookupV2>;
    /** fetch data from the table: "current_ans_lookup_v2" using primary key columns */
    current_ans_lookup_v2_by_pk?: Maybe<CurrentAnsLookupV2>;
    /** fetch data from the table: "current_aptos_names" */
    current_aptos_names: Array<CurrentAptosNames>;
    /** fetch aggregated fields from the table: "current_aptos_names" */
    current_aptos_names_aggregate: CurrentAptosNamesAggregate;
    /** fetch data from the table: "current_coin_balances" */
    current_coin_balances: Array<CurrentCoinBalances>;
    /** fetch data from the table: "current_coin_balances" using primary key columns */
    current_coin_balances_by_pk?: Maybe<CurrentCoinBalances>;
    /** fetch data from the table: "current_collection_datas" */
    current_collection_datas: Array<CurrentCollectionDatas>;
    /** fetch data from the table: "current_collection_datas" using primary key columns */
    current_collection_datas_by_pk?: Maybe<CurrentCollectionDatas>;
    /** fetch data from the table: "current_collection_ownership_v2_view" */
    current_collection_ownership_v2_view: Array<CurrentCollectionOwnershipV2View>;
    /** fetch aggregated fields from the table: "current_collection_ownership_v2_view" */
    current_collection_ownership_v2_view_aggregate: CurrentCollectionOwnershipV2ViewAggregate;
    /** fetch data from the table: "current_collections_v2" */
    current_collections_v2: Array<CurrentCollectionsV2>;
    /** fetch data from the table: "current_collections_v2" using primary key columns */
    current_collections_v2_by_pk?: Maybe<CurrentCollectionsV2>;
    /** fetch data from the table: "current_delegated_staking_pool_balances" */
    current_delegated_staking_pool_balances: Array<CurrentDelegatedStakingPoolBalances>;
    /** fetch data from the table: "current_delegated_staking_pool_balances" using primary key columns */
    current_delegated_staking_pool_balances_by_pk?: Maybe<CurrentDelegatedStakingPoolBalances>;
    /** fetch data from the table: "current_delegated_voter" */
    current_delegated_voter: Array<CurrentDelegatedVoter>;
    /** fetch data from the table: "current_delegated_voter" using primary key columns */
    current_delegated_voter_by_pk?: Maybe<CurrentDelegatedVoter>;
    /** fetch data from the table: "current_delegator_balances" */
    current_delegator_balances: Array<CurrentDelegatorBalances>;
    /** fetch data from the table: "current_delegator_balances" using primary key columns */
    current_delegator_balances_by_pk?: Maybe<CurrentDelegatorBalances>;
    /** fetch data from the table: "current_fungible_asset_balances" */
    current_fungible_asset_balances: Array<CurrentFungibleAssetBalances>;
    /** fetch aggregated fields from the table: "current_fungible_asset_balances" */
    current_fungible_asset_balances_aggregate: CurrentFungibleAssetBalancesAggregate;
    /** fetch data from the table: "current_fungible_asset_balances" using primary key columns */
    current_fungible_asset_balances_by_pk?: Maybe<CurrentFungibleAssetBalances>;
    /** fetch data from the table: "current_objects" */
    current_objects: Array<CurrentObjects>;
    /** fetch data from the table: "current_objects" using primary key columns */
    current_objects_by_pk?: Maybe<CurrentObjects>;
    /** fetch data from the table: "current_staking_pool_voter" */
    current_staking_pool_voter: Array<CurrentStakingPoolVoter>;
    /** fetch data from the table: "current_staking_pool_voter" using primary key columns */
    current_staking_pool_voter_by_pk?: Maybe<CurrentStakingPoolVoter>;
    /** fetch data from the table: "current_table_items" */
    current_table_items: Array<CurrentTableItems>;
    /** fetch data from the table: "current_table_items" using primary key columns */
    current_table_items_by_pk?: Maybe<CurrentTableItems>;
    /** fetch data from the table: "current_token_datas" */
    current_token_datas: Array<CurrentTokenDatas>;
    /** fetch data from the table: "current_token_datas" using primary key columns */
    current_token_datas_by_pk?: Maybe<CurrentTokenDatas>;
    /** fetch data from the table: "current_token_datas_v2" */
    current_token_datas_v2: Array<CurrentTokenDatasV2>;
    /** fetch data from the table: "current_token_datas_v2" using primary key columns */
    current_token_datas_v2_by_pk?: Maybe<CurrentTokenDatasV2>;
    /** fetch data from the table: "current_token_ownerships" */
    current_token_ownerships: Array<CurrentTokenOwnerships>;
    /** fetch aggregated fields from the table: "current_token_ownerships" */
    current_token_ownerships_aggregate: CurrentTokenOwnershipsAggregate;
    /** fetch data from the table: "current_token_ownerships" using primary key columns */
    current_token_ownerships_by_pk?: Maybe<CurrentTokenOwnerships>;
    /** fetch data from the table: "current_token_ownerships_v2" */
    current_token_ownerships_v2: Array<CurrentTokenOwnershipsV2>;
    /** fetch aggregated fields from the table: "current_token_ownerships_v2" */
    current_token_ownerships_v2_aggregate: CurrentTokenOwnershipsV2Aggregate;
    /** fetch data from the table: "current_token_ownerships_v2" using primary key columns */
    current_token_ownerships_v2_by_pk?: Maybe<CurrentTokenOwnershipsV2>;
    /** fetch data from the table: "current_token_pending_claims" */
    current_token_pending_claims: Array<CurrentTokenPendingClaims>;
    /** fetch data from the table: "current_token_pending_claims" using primary key columns */
    current_token_pending_claims_by_pk?: Maybe<CurrentTokenPendingClaims>;
    /** An array relationship */
    delegated_staking_activities: Array<DelegatedStakingActivities>;
    /** fetch data from the table: "delegated_staking_activities" using primary key columns */
    delegated_staking_activities_by_pk?: Maybe<DelegatedStakingActivities>;
    /** fetch data from the table: "delegated_staking_pool_balances" */
    delegated_staking_pool_balances: Array<DelegatedStakingPoolBalances>;
    /** fetch aggregated fields from the table: "delegated_staking_pool_balances" */
    delegated_staking_pool_balances_aggregate: DelegatedStakingPoolBalancesAggregate;
    /** fetch data from the table: "delegated_staking_pool_balances" using primary key columns */
    delegated_staking_pool_balances_by_pk?: Maybe<DelegatedStakingPoolBalances>;
    /** fetch data from the table: "delegated_staking_pools" */
    delegated_staking_pools: Array<DelegatedStakingPools>;
    /** fetch data from the table: "delegated_staking_pools" using primary key columns */
    delegated_staking_pools_by_pk?: Maybe<DelegatedStakingPools>;
    /** fetch data from the table: "delegator_distinct_pool" */
    delegator_distinct_pool: Array<DelegatorDistinctPool>;
    /** fetch aggregated fields from the table: "delegator_distinct_pool" */
    delegator_distinct_pool_aggregate: DelegatorDistinctPoolAggregate;
    /** fetch data from the table: "events" */
    events: Array<Events>;
    /** fetch data from the table: "events" using primary key columns */
    events_by_pk?: Maybe<Events>;
    /** An array relationship */
    fungible_asset_activities: Array<FungibleAssetActivities>;
    /** fetch data from the table: "fungible_asset_activities" using primary key columns */
    fungible_asset_activities_by_pk?: Maybe<FungibleAssetActivities>;
    /** fetch data from the table: "fungible_asset_metadata" */
    fungible_asset_metadata: Array<FungibleAssetMetadata>;
    /** fetch data from the table: "fungible_asset_metadata" using primary key columns */
    fungible_asset_metadata_by_pk?: Maybe<FungibleAssetMetadata>;
    /** fetch data from the table: "indexer_status" */
    indexer_status: Array<IndexerStatus>;
    /** fetch data from the table: "indexer_status" using primary key columns */
    indexer_status_by_pk?: Maybe<IndexerStatus>;
    /** fetch data from the table: "ledger_infos" */
    ledger_infos: Array<LedgerInfos>;
    /** fetch data from the table: "ledger_infos" using primary key columns */
    ledger_infos_by_pk?: Maybe<LedgerInfos>;
    /** fetch data from the table: "move_resources" */
    move_resources: Array<MoveResources>;
    /** fetch aggregated fields from the table: "move_resources" */
    move_resources_aggregate: MoveResourcesAggregate;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_auctions" */
    nft_marketplace_v2_current_nft_marketplace_auctions: Array<NftMarketplaceV2CurrentNftMarketplaceAuctions>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_auctions" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_auctions_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceAuctions>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_collection_offers" */
    nft_marketplace_v2_current_nft_marketplace_collection_offers: Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffers>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_collection_offers" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_collection_offers_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffers>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_listings" */
    nft_marketplace_v2_current_nft_marketplace_listings: Array<NftMarketplaceV2CurrentNftMarketplaceListings>;
    /** fetch aggregated fields from the table: "nft_marketplace_v2.current_nft_marketplace_listings" */
    nft_marketplace_v2_current_nft_marketplace_listings_aggregate: NftMarketplaceV2CurrentNftMarketplaceListingsAggregate;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_listings" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_listings_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListings>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_token_offers" */
    nft_marketplace_v2_current_nft_marketplace_token_offers: Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffers>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_token_offers" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_token_offers_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffers>;
    /** fetch data from the table: "nft_marketplace_v2.nft_marketplace_activities" */
    nft_marketplace_v2_nft_marketplace_activities: Array<NftMarketplaceV2NftMarketplaceActivities>;
    /** fetch data from the table: "nft_marketplace_v2.nft_marketplace_activities" using primary key columns */
    nft_marketplace_v2_nft_marketplace_activities_by_pk?: Maybe<NftMarketplaceV2NftMarketplaceActivities>;
    /** fetch data from the table: "nft_metadata_crawler.parsed_asset_uris" */
    nft_metadata_crawler_parsed_asset_uris: Array<NftMetadataCrawlerParsedAssetUris>;
    /** fetch data from the table: "nft_metadata_crawler.parsed_asset_uris" using primary key columns */
    nft_metadata_crawler_parsed_asset_uris_by_pk?: Maybe<NftMetadataCrawlerParsedAssetUris>;
    /** fetch data from the table: "num_active_delegator_per_pool" */
    num_active_delegator_per_pool: Array<NumActiveDelegatorPerPool>;
    /** fetch data from the table: "processor_status" */
    processor_status: Array<ProcessorStatus>;
    /** fetch data from the table: "processor_status" using primary key columns */
    processor_status_by_pk?: Maybe<ProcessorStatus>;
    /** fetch data from the table: "proposal_votes" */
    proposal_votes: Array<ProposalVotes>;
    /** fetch aggregated fields from the table: "proposal_votes" */
    proposal_votes_aggregate: ProposalVotesAggregate;
    /** fetch data from the table: "proposal_votes" using primary key columns */
    proposal_votes_by_pk?: Maybe<ProposalVotes>;
    /** fetch data from the table: "signatures" */
    signatures: Array<Signatures>;
    /** fetch data from the table: "signatures" using primary key columns */
    signatures_by_pk?: Maybe<Signatures>;
    /** fetch data from the table: "table_items" */
    table_items: Array<TableItems>;
    /** fetch data from the table: "table_items" using primary key columns */
    table_items_by_pk?: Maybe<TableItems>;
    /** fetch data from the table: "table_metadatas" */
    table_metadatas: Array<TableMetadatas>;
    /** fetch data from the table: "table_metadatas" using primary key columns */
    table_metadatas_by_pk?: Maybe<TableMetadatas>;
    /** An array relationship */
    token_activities: Array<TokenActivities>;
    /** An aggregate relationship */
    token_activities_aggregate: TokenActivitiesAggregate;
    /** fetch data from the table: "token_activities" using primary key columns */
    token_activities_by_pk?: Maybe<TokenActivities>;
    /** An array relationship */
    token_activities_v2: Array<TokenActivitiesV2>;
    /** An aggregate relationship */
    token_activities_v2_aggregate: TokenActivitiesV2Aggregate;
    /** fetch data from the table: "token_activities_v2" using primary key columns */
    token_activities_v2_by_pk?: Maybe<TokenActivitiesV2>;
    /** fetch data from the table: "token_datas" */
    token_datas: Array<TokenDatas>;
    /** fetch data from the table: "token_datas" using primary key columns */
    token_datas_by_pk?: Maybe<TokenDatas>;
    /** fetch data from the table: "token_ownerships" */
    token_ownerships: Array<TokenOwnerships>;
    /** fetch data from the table: "token_ownerships" using primary key columns */
    token_ownerships_by_pk?: Maybe<TokenOwnerships>;
    /** fetch data from the table: "tokens" */
    tokens: Array<Tokens>;
    /** fetch data from the table: "tokens" using primary key columns */
    tokens_by_pk?: Maybe<Tokens>;
    /** fetch data from the table: "user_transactions" */
    user_transactions: Array<UserTransactions>;
    /** fetch data from the table: "user_transactions" using primary key columns */
    user_transactions_by_pk?: Maybe<UserTransactions>;
};
type QueryRootAccountTransactionsArgs = {
    distinct_on?: InputMaybe<Array<AccountTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AccountTransactionsOrderBy>>;
    where?: InputMaybe<AccountTransactionsBoolExp>;
};
type QueryRootAccountTransactionsAggregateArgs = {
    distinct_on?: InputMaybe<Array<AccountTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AccountTransactionsOrderBy>>;
    where?: InputMaybe<AccountTransactionsBoolExp>;
};
type QueryRootAccountTransactionsByPkArgs = {
    account_address: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootAddressEventsSummaryArgs = {
    distinct_on?: InputMaybe<Array<AddressEventsSummarySelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressEventsSummaryOrderBy>>;
    where?: InputMaybe<AddressEventsSummaryBoolExp>;
};
type QueryRootAddressVersionFromEventsArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromEventsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromEventsOrderBy>>;
    where?: InputMaybe<AddressVersionFromEventsBoolExp>;
};
type QueryRootAddressVersionFromEventsAggregateArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromEventsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromEventsOrderBy>>;
    where?: InputMaybe<AddressVersionFromEventsBoolExp>;
};
type QueryRootAddressVersionFromMoveResourcesArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromMoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromMoveResourcesOrderBy>>;
    where?: InputMaybe<AddressVersionFromMoveResourcesBoolExp>;
};
type QueryRootAddressVersionFromMoveResourcesAggregateArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromMoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromMoveResourcesOrderBy>>;
    where?: InputMaybe<AddressVersionFromMoveResourcesBoolExp>;
};
type QueryRootBlockMetadataTransactionsArgs = {
    distinct_on?: InputMaybe<Array<BlockMetadataTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<BlockMetadataTransactionsOrderBy>>;
    where?: InputMaybe<BlockMetadataTransactionsBoolExp>;
};
type QueryRootBlockMetadataTransactionsByPkArgs = {
    version: Scalars["bigint"]["input"];
};
type QueryRootCoinActivitiesArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
type QueryRootCoinActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
type QueryRootCoinActivitiesByPkArgs = {
    event_account_address: Scalars["String"]["input"];
    event_creation_number: Scalars["bigint"]["input"];
    event_sequence_number: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootCoinBalancesArgs = {
    distinct_on?: InputMaybe<Array<CoinBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinBalancesOrderBy>>;
    where?: InputMaybe<CoinBalancesBoolExp>;
};
type QueryRootCoinBalancesByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
    owner_address: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootCoinInfosArgs = {
    distinct_on?: InputMaybe<Array<CoinInfosSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinInfosOrderBy>>;
    where?: InputMaybe<CoinInfosBoolExp>;
};
type QueryRootCoinInfosByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
};
type QueryRootCoinSupplyArgs = {
    distinct_on?: InputMaybe<Array<CoinSupplySelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinSupplyOrderBy>>;
    where?: InputMaybe<CoinSupplyBoolExp>;
};
type QueryRootCoinSupplyByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootCollectionDatasArgs = {
    distinct_on?: InputMaybe<Array<CollectionDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CollectionDatasOrderBy>>;
    where?: InputMaybe<CollectionDatasBoolExp>;
};
type QueryRootCollectionDatasByPkArgs = {
    collection_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootCurrentAnsLookupArgs = {
    distinct_on?: InputMaybe<Array<CurrentAnsLookupSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAnsLookupOrderBy>>;
    where?: InputMaybe<CurrentAnsLookupBoolExp>;
};
type QueryRootCurrentAnsLookupByPkArgs = {
    domain: Scalars["String"]["input"];
    subdomain: Scalars["String"]["input"];
};
type QueryRootCurrentAnsLookupV2Args = {
    distinct_on?: InputMaybe<Array<CurrentAnsLookupV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAnsLookupV2OrderBy>>;
    where?: InputMaybe<CurrentAnsLookupV2BoolExp>;
};
type QueryRootCurrentAnsLookupV2ByPkArgs = {
    domain: Scalars["String"]["input"];
    subdomain: Scalars["String"]["input"];
    token_standard: Scalars["String"]["input"];
};
type QueryRootCurrentAptosNamesArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
type QueryRootCurrentAptosNamesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
type QueryRootCurrentCoinBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentCoinBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCoinBalancesOrderBy>>;
    where?: InputMaybe<CurrentCoinBalancesBoolExp>;
};
type QueryRootCurrentCoinBalancesByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
    owner_address: Scalars["String"]["input"];
};
type QueryRootCurrentCollectionDatasArgs = {
    distinct_on?: InputMaybe<Array<CurrentCollectionDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionDatasOrderBy>>;
    where?: InputMaybe<CurrentCollectionDatasBoolExp>;
};
type QueryRootCurrentCollectionDatasByPkArgs = {
    collection_data_id_hash: Scalars["String"]["input"];
};
type QueryRootCurrentCollectionOwnershipV2ViewArgs = {
    distinct_on?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewOrderBy>>;
    where?: InputMaybe<CurrentCollectionOwnershipV2ViewBoolExp>;
};
type QueryRootCurrentCollectionOwnershipV2ViewAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewOrderBy>>;
    where?: InputMaybe<CurrentCollectionOwnershipV2ViewBoolExp>;
};
type QueryRootCurrentCollectionsV2Args = {
    distinct_on?: InputMaybe<Array<CurrentCollectionsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionsV2OrderBy>>;
    where?: InputMaybe<CurrentCollectionsV2BoolExp>;
};
type QueryRootCurrentCollectionsV2ByPkArgs = {
    collection_id: Scalars["String"]["input"];
};
type QueryRootCurrentDelegatedStakingPoolBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentDelegatedStakingPoolBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentDelegatedStakingPoolBalancesOrderBy>>;
    where?: InputMaybe<CurrentDelegatedStakingPoolBalancesBoolExp>;
};
type QueryRootCurrentDelegatedStakingPoolBalancesByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
};
type QueryRootCurrentDelegatedVoterArgs = {
    distinct_on?: InputMaybe<Array<CurrentDelegatedVoterSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentDelegatedVoterOrderBy>>;
    where?: InputMaybe<CurrentDelegatedVoterBoolExp>;
};
type QueryRootCurrentDelegatedVoterByPkArgs = {
    delegation_pool_address: Scalars["String"]["input"];
    delegator_address: Scalars["String"]["input"];
};
type QueryRootCurrentDelegatorBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentDelegatorBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentDelegatorBalancesOrderBy>>;
    where?: InputMaybe<CurrentDelegatorBalancesBoolExp>;
};
type QueryRootCurrentDelegatorBalancesByPkArgs = {
    delegator_address: Scalars["String"]["input"];
    pool_address: Scalars["String"]["input"];
    pool_type: Scalars["String"]["input"];
    table_handle: Scalars["String"]["input"];
};
type QueryRootCurrentFungibleAssetBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentFungibleAssetBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentFungibleAssetBalancesOrderBy>>;
    where?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
};
type QueryRootCurrentFungibleAssetBalancesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentFungibleAssetBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentFungibleAssetBalancesOrderBy>>;
    where?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
};
type QueryRootCurrentFungibleAssetBalancesByPkArgs = {
    storage_id: Scalars["String"]["input"];
};
type QueryRootCurrentObjectsArgs = {
    distinct_on?: InputMaybe<Array<CurrentObjectsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentObjectsOrderBy>>;
    where?: InputMaybe<CurrentObjectsBoolExp>;
};
type QueryRootCurrentObjectsByPkArgs = {
    object_address: Scalars["String"]["input"];
};
type QueryRootCurrentStakingPoolVoterArgs = {
    distinct_on?: InputMaybe<Array<CurrentStakingPoolVoterSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentStakingPoolVoterOrderBy>>;
    where?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
};
type QueryRootCurrentStakingPoolVoterByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
};
type QueryRootCurrentTableItemsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTableItemsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTableItemsOrderBy>>;
    where?: InputMaybe<CurrentTableItemsBoolExp>;
};
type QueryRootCurrentTableItemsByPkArgs = {
    key_hash: Scalars["String"]["input"];
    table_handle: Scalars["String"]["input"];
};
type QueryRootCurrentTokenDatasArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenDatasOrderBy>>;
    where?: InputMaybe<CurrentTokenDatasBoolExp>;
};
type QueryRootCurrentTokenDatasByPkArgs = {
    token_data_id_hash: Scalars["String"]["input"];
};
type QueryRootCurrentTokenDatasV2Args = {
    distinct_on?: InputMaybe<Array<CurrentTokenDatasV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenDatasV2OrderBy>>;
    where?: InputMaybe<CurrentTokenDatasV2BoolExp>;
};
type QueryRootCurrentTokenDatasV2ByPkArgs = {
    token_data_id: Scalars["String"]["input"];
};
type QueryRootCurrentTokenOwnershipsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsOrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
type QueryRootCurrentTokenOwnershipsAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsOrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
type QueryRootCurrentTokenOwnershipsByPkArgs = {
    owner_address: Scalars["String"]["input"];
    property_version: Scalars["numeric"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
};
type QueryRootCurrentTokenOwnershipsV2Args = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
type QueryRootCurrentTokenOwnershipsV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
type QueryRootCurrentTokenOwnershipsV2ByPkArgs = {
    owner_address: Scalars["String"]["input"];
    property_version_v1: Scalars["numeric"]["input"];
    storage_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type QueryRootCurrentTokenPendingClaimsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenPendingClaimsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenPendingClaimsOrderBy>>;
    where?: InputMaybe<CurrentTokenPendingClaimsBoolExp>;
};
type QueryRootCurrentTokenPendingClaimsByPkArgs = {
    from_address: Scalars["String"]["input"];
    property_version: Scalars["numeric"]["input"];
    to_address: Scalars["String"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
};
type QueryRootDelegatedStakingActivitiesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingActivitiesOrderBy>>;
    where?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
};
type QueryRootDelegatedStakingActivitiesByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootDelegatedStakingPoolBalancesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingPoolBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingPoolBalancesOrderBy>>;
    where?: InputMaybe<DelegatedStakingPoolBalancesBoolExp>;
};
type QueryRootDelegatedStakingPoolBalancesAggregateArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingPoolBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingPoolBalancesOrderBy>>;
    where?: InputMaybe<DelegatedStakingPoolBalancesBoolExp>;
};
type QueryRootDelegatedStakingPoolBalancesByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootDelegatedStakingPoolsArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingPoolsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingPoolsOrderBy>>;
    where?: InputMaybe<DelegatedStakingPoolsBoolExp>;
};
type QueryRootDelegatedStakingPoolsByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
};
type QueryRootDelegatorDistinctPoolArgs = {
    distinct_on?: InputMaybe<Array<DelegatorDistinctPoolSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatorDistinctPoolOrderBy>>;
    where?: InputMaybe<DelegatorDistinctPoolBoolExp>;
};
type QueryRootDelegatorDistinctPoolAggregateArgs = {
    distinct_on?: InputMaybe<Array<DelegatorDistinctPoolSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatorDistinctPoolOrderBy>>;
    where?: InputMaybe<DelegatorDistinctPoolBoolExp>;
};
type QueryRootEventsArgs = {
    distinct_on?: InputMaybe<Array<EventsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<EventsOrderBy>>;
    where?: InputMaybe<EventsBoolExp>;
};
type QueryRootEventsByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootFungibleAssetActivitiesArgs = {
    distinct_on?: InputMaybe<Array<FungibleAssetActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<FungibleAssetActivitiesOrderBy>>;
    where?: InputMaybe<FungibleAssetActivitiesBoolExp>;
};
type QueryRootFungibleAssetActivitiesByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootFungibleAssetMetadataArgs = {
    distinct_on?: InputMaybe<Array<FungibleAssetMetadataSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<FungibleAssetMetadataOrderBy>>;
    where?: InputMaybe<FungibleAssetMetadataBoolExp>;
};
type QueryRootFungibleAssetMetadataByPkArgs = {
    asset_type: Scalars["String"]["input"];
};
type QueryRootIndexerStatusArgs = {
    distinct_on?: InputMaybe<Array<IndexerStatusSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<IndexerStatusOrderBy>>;
    where?: InputMaybe<IndexerStatusBoolExp>;
};
type QueryRootIndexerStatusByPkArgs = {
    db: Scalars["String"]["input"];
};
type QueryRootLedgerInfosArgs = {
    distinct_on?: InputMaybe<Array<LedgerInfosSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<LedgerInfosOrderBy>>;
    where?: InputMaybe<LedgerInfosBoolExp>;
};
type QueryRootLedgerInfosByPkArgs = {
    chain_id: Scalars["bigint"]["input"];
};
type QueryRootMoveResourcesArgs = {
    distinct_on?: InputMaybe<Array<MoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<MoveResourcesOrderBy>>;
    where?: InputMaybe<MoveResourcesBoolExp>;
};
type QueryRootMoveResourcesAggregateArgs = {
    distinct_on?: InputMaybe<Array<MoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<MoveResourcesOrderBy>>;
    where?: InputMaybe<MoveResourcesBoolExp>;
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceAuctionsArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceAuctionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceAuctionsOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp>;
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceAuctionsByPkArgs = {
    listing_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp>;
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersByPkArgs = {
    collection_id: Scalars["String"]["input"];
    collection_offer_id: Scalars["String"]["input"];
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceListingsArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>;
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceListingsAggregateArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>;
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceListingsByPkArgs = {
    listing_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffersSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffersOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp>;
};
type QueryRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersByPkArgs = {
    offer_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type QueryRootNftMarketplaceV2NftMarketplaceActivitiesArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2NftMarketplaceActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2NftMarketplaceActivitiesOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2NftMarketplaceActivitiesBoolExp>;
};
type QueryRootNftMarketplaceV2NftMarketplaceActivitiesByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootNftMetadataCrawlerParsedAssetUrisArgs = {
    distinct_on?: InputMaybe<Array<NftMetadataCrawlerParsedAssetUrisSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMetadataCrawlerParsedAssetUrisOrderBy>>;
    where?: InputMaybe<NftMetadataCrawlerParsedAssetUrisBoolExp>;
};
type QueryRootNftMetadataCrawlerParsedAssetUrisByPkArgs = {
    asset_uri: Scalars["String"]["input"];
};
type QueryRootNumActiveDelegatorPerPoolArgs = {
    distinct_on?: InputMaybe<Array<NumActiveDelegatorPerPoolSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NumActiveDelegatorPerPoolOrderBy>>;
    where?: InputMaybe<NumActiveDelegatorPerPoolBoolExp>;
};
type QueryRootProcessorStatusArgs = {
    distinct_on?: InputMaybe<Array<ProcessorStatusSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<ProcessorStatusOrderBy>>;
    where?: InputMaybe<ProcessorStatusBoolExp>;
};
type QueryRootProcessorStatusByPkArgs = {
    processor: Scalars["String"]["input"];
};
type QueryRootProposalVotesArgs = {
    distinct_on?: InputMaybe<Array<ProposalVotesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<ProposalVotesOrderBy>>;
    where?: InputMaybe<ProposalVotesBoolExp>;
};
type QueryRootProposalVotesAggregateArgs = {
    distinct_on?: InputMaybe<Array<ProposalVotesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<ProposalVotesOrderBy>>;
    where?: InputMaybe<ProposalVotesBoolExp>;
};
type QueryRootProposalVotesByPkArgs = {
    proposal_id: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
    voter_address: Scalars["String"]["input"];
};
type QueryRootSignaturesArgs = {
    distinct_on?: InputMaybe<Array<SignaturesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<SignaturesOrderBy>>;
    where?: InputMaybe<SignaturesBoolExp>;
};
type QueryRootSignaturesByPkArgs = {
    is_sender_primary: Scalars["Boolean"]["input"];
    multi_agent_index: Scalars["bigint"]["input"];
    multi_sig_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootTableItemsArgs = {
    distinct_on?: InputMaybe<Array<TableItemsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TableItemsOrderBy>>;
    where?: InputMaybe<TableItemsBoolExp>;
};
type QueryRootTableItemsByPkArgs = {
    transaction_version: Scalars["bigint"]["input"];
    write_set_change_index: Scalars["bigint"]["input"];
};
type QueryRootTableMetadatasArgs = {
    distinct_on?: InputMaybe<Array<TableMetadatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TableMetadatasOrderBy>>;
    where?: InputMaybe<TableMetadatasBoolExp>;
};
type QueryRootTableMetadatasByPkArgs = {
    handle: Scalars["String"]["input"];
};
type QueryRootTokenActivitiesArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
type QueryRootTokenActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
type QueryRootTokenActivitiesByPkArgs = {
    event_account_address: Scalars["String"]["input"];
    event_creation_number: Scalars["bigint"]["input"];
    event_sequence_number: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootTokenActivitiesV2Args = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
type QueryRootTokenActivitiesV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
type QueryRootTokenActivitiesV2ByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootTokenDatasArgs = {
    distinct_on?: InputMaybe<Array<TokenDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenDatasOrderBy>>;
    where?: InputMaybe<TokenDatasBoolExp>;
};
type QueryRootTokenDatasByPkArgs = {
    token_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootTokenOwnershipsArgs = {
    distinct_on?: InputMaybe<Array<TokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenOwnershipsOrderBy>>;
    where?: InputMaybe<TokenOwnershipsBoolExp>;
};
type QueryRootTokenOwnershipsByPkArgs = {
    property_version: Scalars["numeric"]["input"];
    table_handle: Scalars["String"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootTokensArgs = {
    distinct_on?: InputMaybe<Array<TokensSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokensOrderBy>>;
    where?: InputMaybe<TokensBoolExp>;
};
type QueryRootTokensByPkArgs = {
    property_version: Scalars["numeric"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type QueryRootUserTransactionsArgs = {
    distinct_on?: InputMaybe<Array<UserTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<UserTransactionsOrderBy>>;
    where?: InputMaybe<UserTransactionsBoolExp>;
};
type QueryRootUserTransactionsByPkArgs = {
    version: Scalars["bigint"]["input"];
};
/** columns and relationships of "signatures" */
type Signatures = {
    is_sender_primary: Scalars["Boolean"]["output"];
    multi_agent_index: Scalars["bigint"]["output"];
    multi_sig_index: Scalars["bigint"]["output"];
    public_key: Scalars["String"]["output"];
    public_key_indices: Scalars["jsonb"]["output"];
    signature: Scalars["String"]["output"];
    signer: Scalars["String"]["output"];
    threshold: Scalars["bigint"]["output"];
    transaction_block_height: Scalars["bigint"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    type: Scalars["String"]["output"];
};
/** columns and relationships of "signatures" */
type SignaturesPublicKeyIndicesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "signatures". All fields are combined with a logical 'AND'. */
type SignaturesBoolExp = {
    _and?: InputMaybe<Array<SignaturesBoolExp>>;
    _not?: InputMaybe<SignaturesBoolExp>;
    _or?: InputMaybe<Array<SignaturesBoolExp>>;
    is_sender_primary?: InputMaybe<BooleanComparisonExp>;
    multi_agent_index?: InputMaybe<BigintComparisonExp>;
    multi_sig_index?: InputMaybe<BigintComparisonExp>;
    public_key?: InputMaybe<StringComparisonExp>;
    public_key_indices?: InputMaybe<JsonbComparisonExp>;
    signature?: InputMaybe<StringComparisonExp>;
    signer?: InputMaybe<StringComparisonExp>;
    threshold?: InputMaybe<BigintComparisonExp>;
    transaction_block_height?: InputMaybe<BigintComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    type?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "signatures". */
type SignaturesOrderBy = {
    is_sender_primary?: InputMaybe<OrderBy>;
    multi_agent_index?: InputMaybe<OrderBy>;
    multi_sig_index?: InputMaybe<OrderBy>;
    public_key?: InputMaybe<OrderBy>;
    public_key_indices?: InputMaybe<OrderBy>;
    signature?: InputMaybe<OrderBy>;
    signer?: InputMaybe<OrderBy>;
    threshold?: InputMaybe<OrderBy>;
    transaction_block_height?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** select columns of table "signatures" */
declare enum SignaturesSelectColumn {
    /** column name */
    IsSenderPrimary = "is_sender_primary",
    /** column name */
    MultiAgentIndex = "multi_agent_index",
    /** column name */
    MultiSigIndex = "multi_sig_index",
    /** column name */
    PublicKey = "public_key",
    /** column name */
    PublicKeyIndices = "public_key_indices",
    /** column name */
    Signature = "signature",
    /** column name */
    Signer = "signer",
    /** column name */
    Threshold = "threshold",
    /** column name */
    TransactionBlockHeight = "transaction_block_height",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    Type = "type"
}
/** Streaming cursor of the table "signatures" */
type SignaturesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: SignaturesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type SignaturesStreamCursorValueInput = {
    is_sender_primary?: InputMaybe<Scalars["Boolean"]["input"]>;
    multi_agent_index?: InputMaybe<Scalars["bigint"]["input"]>;
    multi_sig_index?: InputMaybe<Scalars["bigint"]["input"]>;
    public_key?: InputMaybe<Scalars["String"]["input"]>;
    public_key_indices?: InputMaybe<Scalars["jsonb"]["input"]>;
    signature?: InputMaybe<Scalars["String"]["input"]>;
    signer?: InputMaybe<Scalars["String"]["input"]>;
    threshold?: InputMaybe<Scalars["bigint"]["input"]>;
    transaction_block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    type?: InputMaybe<Scalars["String"]["input"]>;
};
type SubscriptionRoot = {
    /** fetch data from the table: "account_transactions" */
    account_transactions: Array<AccountTransactions>;
    /** fetch aggregated fields from the table: "account_transactions" */
    account_transactions_aggregate: AccountTransactionsAggregate;
    /** fetch data from the table: "account_transactions" using primary key columns */
    account_transactions_by_pk?: Maybe<AccountTransactions>;
    /** fetch data from the table in a streaming manner: "account_transactions" */
    account_transactions_stream: Array<AccountTransactions>;
    /** fetch data from the table: "address_events_summary" */
    address_events_summary: Array<AddressEventsSummary>;
    /** fetch data from the table in a streaming manner: "address_events_summary" */
    address_events_summary_stream: Array<AddressEventsSummary>;
    /** fetch data from the table: "address_version_from_events" */
    address_version_from_events: Array<AddressVersionFromEvents>;
    /** fetch aggregated fields from the table: "address_version_from_events" */
    address_version_from_events_aggregate: AddressVersionFromEventsAggregate;
    /** fetch data from the table in a streaming manner: "address_version_from_events" */
    address_version_from_events_stream: Array<AddressVersionFromEvents>;
    /** fetch data from the table: "address_version_from_move_resources" */
    address_version_from_move_resources: Array<AddressVersionFromMoveResources>;
    /** fetch aggregated fields from the table: "address_version_from_move_resources" */
    address_version_from_move_resources_aggregate: AddressVersionFromMoveResourcesAggregate;
    /** fetch data from the table in a streaming manner: "address_version_from_move_resources" */
    address_version_from_move_resources_stream: Array<AddressVersionFromMoveResources>;
    /** fetch data from the table: "block_metadata_transactions" */
    block_metadata_transactions: Array<BlockMetadataTransactions>;
    /** fetch data from the table: "block_metadata_transactions" using primary key columns */
    block_metadata_transactions_by_pk?: Maybe<BlockMetadataTransactions>;
    /** fetch data from the table in a streaming manner: "block_metadata_transactions" */
    block_metadata_transactions_stream: Array<BlockMetadataTransactions>;
    /** An array relationship */
    coin_activities: Array<CoinActivities>;
    /** An aggregate relationship */
    coin_activities_aggregate: CoinActivitiesAggregate;
    /** fetch data from the table: "coin_activities" using primary key columns */
    coin_activities_by_pk?: Maybe<CoinActivities>;
    /** fetch data from the table in a streaming manner: "coin_activities" */
    coin_activities_stream: Array<CoinActivities>;
    /** fetch data from the table: "coin_balances" */
    coin_balances: Array<CoinBalances>;
    /** fetch data from the table: "coin_balances" using primary key columns */
    coin_balances_by_pk?: Maybe<CoinBalances>;
    /** fetch data from the table in a streaming manner: "coin_balances" */
    coin_balances_stream: Array<CoinBalances>;
    /** fetch data from the table: "coin_infos" */
    coin_infos: Array<CoinInfos>;
    /** fetch data from the table: "coin_infos" using primary key columns */
    coin_infos_by_pk?: Maybe<CoinInfos>;
    /** fetch data from the table in a streaming manner: "coin_infos" */
    coin_infos_stream: Array<CoinInfos>;
    /** fetch data from the table: "coin_supply" */
    coin_supply: Array<CoinSupply>;
    /** fetch data from the table: "coin_supply" using primary key columns */
    coin_supply_by_pk?: Maybe<CoinSupply>;
    /** fetch data from the table in a streaming manner: "coin_supply" */
    coin_supply_stream: Array<CoinSupply>;
    /** fetch data from the table: "collection_datas" */
    collection_datas: Array<CollectionDatas>;
    /** fetch data from the table: "collection_datas" using primary key columns */
    collection_datas_by_pk?: Maybe<CollectionDatas>;
    /** fetch data from the table in a streaming manner: "collection_datas" */
    collection_datas_stream: Array<CollectionDatas>;
    /** fetch data from the table: "current_ans_lookup" */
    current_ans_lookup: Array<CurrentAnsLookup>;
    /** fetch data from the table: "current_ans_lookup" using primary key columns */
    current_ans_lookup_by_pk?: Maybe<CurrentAnsLookup>;
    /** fetch data from the table in a streaming manner: "current_ans_lookup" */
    current_ans_lookup_stream: Array<CurrentAnsLookup>;
    /** fetch data from the table: "current_ans_lookup_v2" */
    current_ans_lookup_v2: Array<CurrentAnsLookupV2>;
    /** fetch data from the table: "current_ans_lookup_v2" using primary key columns */
    current_ans_lookup_v2_by_pk?: Maybe<CurrentAnsLookupV2>;
    /** fetch data from the table in a streaming manner: "current_ans_lookup_v2" */
    current_ans_lookup_v2_stream: Array<CurrentAnsLookupV2>;
    /** fetch data from the table: "current_aptos_names" */
    current_aptos_names: Array<CurrentAptosNames>;
    /** fetch aggregated fields from the table: "current_aptos_names" */
    current_aptos_names_aggregate: CurrentAptosNamesAggregate;
    /** fetch data from the table in a streaming manner: "current_aptos_names" */
    current_aptos_names_stream: Array<CurrentAptosNames>;
    /** fetch data from the table: "current_coin_balances" */
    current_coin_balances: Array<CurrentCoinBalances>;
    /** fetch data from the table: "current_coin_balances" using primary key columns */
    current_coin_balances_by_pk?: Maybe<CurrentCoinBalances>;
    /** fetch data from the table in a streaming manner: "current_coin_balances" */
    current_coin_balances_stream: Array<CurrentCoinBalances>;
    /** fetch data from the table: "current_collection_datas" */
    current_collection_datas: Array<CurrentCollectionDatas>;
    /** fetch data from the table: "current_collection_datas" using primary key columns */
    current_collection_datas_by_pk?: Maybe<CurrentCollectionDatas>;
    /** fetch data from the table in a streaming manner: "current_collection_datas" */
    current_collection_datas_stream: Array<CurrentCollectionDatas>;
    /** fetch data from the table: "current_collection_ownership_v2_view" */
    current_collection_ownership_v2_view: Array<CurrentCollectionOwnershipV2View>;
    /** fetch aggregated fields from the table: "current_collection_ownership_v2_view" */
    current_collection_ownership_v2_view_aggregate: CurrentCollectionOwnershipV2ViewAggregate;
    /** fetch data from the table in a streaming manner: "current_collection_ownership_v2_view" */
    current_collection_ownership_v2_view_stream: Array<CurrentCollectionOwnershipV2View>;
    /** fetch data from the table: "current_collections_v2" */
    current_collections_v2: Array<CurrentCollectionsV2>;
    /** fetch data from the table: "current_collections_v2" using primary key columns */
    current_collections_v2_by_pk?: Maybe<CurrentCollectionsV2>;
    /** fetch data from the table in a streaming manner: "current_collections_v2" */
    current_collections_v2_stream: Array<CurrentCollectionsV2>;
    /** fetch data from the table: "current_delegated_staking_pool_balances" */
    current_delegated_staking_pool_balances: Array<CurrentDelegatedStakingPoolBalances>;
    /** fetch data from the table: "current_delegated_staking_pool_balances" using primary key columns */
    current_delegated_staking_pool_balances_by_pk?: Maybe<CurrentDelegatedStakingPoolBalances>;
    /** fetch data from the table in a streaming manner: "current_delegated_staking_pool_balances" */
    current_delegated_staking_pool_balances_stream: Array<CurrentDelegatedStakingPoolBalances>;
    /** fetch data from the table: "current_delegated_voter" */
    current_delegated_voter: Array<CurrentDelegatedVoter>;
    /** fetch data from the table: "current_delegated_voter" using primary key columns */
    current_delegated_voter_by_pk?: Maybe<CurrentDelegatedVoter>;
    /** fetch data from the table in a streaming manner: "current_delegated_voter" */
    current_delegated_voter_stream: Array<CurrentDelegatedVoter>;
    /** fetch data from the table: "current_delegator_balances" */
    current_delegator_balances: Array<CurrentDelegatorBalances>;
    /** fetch data from the table: "current_delegator_balances" using primary key columns */
    current_delegator_balances_by_pk?: Maybe<CurrentDelegatorBalances>;
    /** fetch data from the table in a streaming manner: "current_delegator_balances" */
    current_delegator_balances_stream: Array<CurrentDelegatorBalances>;
    /** fetch data from the table: "current_fungible_asset_balances" */
    current_fungible_asset_balances: Array<CurrentFungibleAssetBalances>;
    /** fetch aggregated fields from the table: "current_fungible_asset_balances" */
    current_fungible_asset_balances_aggregate: CurrentFungibleAssetBalancesAggregate;
    /** fetch data from the table: "current_fungible_asset_balances" using primary key columns */
    current_fungible_asset_balances_by_pk?: Maybe<CurrentFungibleAssetBalances>;
    /** fetch data from the table in a streaming manner: "current_fungible_asset_balances" */
    current_fungible_asset_balances_stream: Array<CurrentFungibleAssetBalances>;
    /** fetch data from the table: "current_objects" */
    current_objects: Array<CurrentObjects>;
    /** fetch data from the table: "current_objects" using primary key columns */
    current_objects_by_pk?: Maybe<CurrentObjects>;
    /** fetch data from the table in a streaming manner: "current_objects" */
    current_objects_stream: Array<CurrentObjects>;
    /** fetch data from the table: "current_staking_pool_voter" */
    current_staking_pool_voter: Array<CurrentStakingPoolVoter>;
    /** fetch data from the table: "current_staking_pool_voter" using primary key columns */
    current_staking_pool_voter_by_pk?: Maybe<CurrentStakingPoolVoter>;
    /** fetch data from the table in a streaming manner: "current_staking_pool_voter" */
    current_staking_pool_voter_stream: Array<CurrentStakingPoolVoter>;
    /** fetch data from the table: "current_table_items" */
    current_table_items: Array<CurrentTableItems>;
    /** fetch data from the table: "current_table_items" using primary key columns */
    current_table_items_by_pk?: Maybe<CurrentTableItems>;
    /** fetch data from the table in a streaming manner: "current_table_items" */
    current_table_items_stream: Array<CurrentTableItems>;
    /** fetch data from the table: "current_token_datas" */
    current_token_datas: Array<CurrentTokenDatas>;
    /** fetch data from the table: "current_token_datas" using primary key columns */
    current_token_datas_by_pk?: Maybe<CurrentTokenDatas>;
    /** fetch data from the table in a streaming manner: "current_token_datas" */
    current_token_datas_stream: Array<CurrentTokenDatas>;
    /** fetch data from the table: "current_token_datas_v2" */
    current_token_datas_v2: Array<CurrentTokenDatasV2>;
    /** fetch data from the table: "current_token_datas_v2" using primary key columns */
    current_token_datas_v2_by_pk?: Maybe<CurrentTokenDatasV2>;
    /** fetch data from the table in a streaming manner: "current_token_datas_v2" */
    current_token_datas_v2_stream: Array<CurrentTokenDatasV2>;
    /** fetch data from the table: "current_token_ownerships" */
    current_token_ownerships: Array<CurrentTokenOwnerships>;
    /** fetch aggregated fields from the table: "current_token_ownerships" */
    current_token_ownerships_aggregate: CurrentTokenOwnershipsAggregate;
    /** fetch data from the table: "current_token_ownerships" using primary key columns */
    current_token_ownerships_by_pk?: Maybe<CurrentTokenOwnerships>;
    /** fetch data from the table in a streaming manner: "current_token_ownerships" */
    current_token_ownerships_stream: Array<CurrentTokenOwnerships>;
    /** fetch data from the table: "current_token_ownerships_v2" */
    current_token_ownerships_v2: Array<CurrentTokenOwnershipsV2>;
    /** fetch aggregated fields from the table: "current_token_ownerships_v2" */
    current_token_ownerships_v2_aggregate: CurrentTokenOwnershipsV2Aggregate;
    /** fetch data from the table: "current_token_ownerships_v2" using primary key columns */
    current_token_ownerships_v2_by_pk?: Maybe<CurrentTokenOwnershipsV2>;
    /** fetch data from the table in a streaming manner: "current_token_ownerships_v2" */
    current_token_ownerships_v2_stream: Array<CurrentTokenOwnershipsV2>;
    /** fetch data from the table: "current_token_pending_claims" */
    current_token_pending_claims: Array<CurrentTokenPendingClaims>;
    /** fetch data from the table: "current_token_pending_claims" using primary key columns */
    current_token_pending_claims_by_pk?: Maybe<CurrentTokenPendingClaims>;
    /** fetch data from the table in a streaming manner: "current_token_pending_claims" */
    current_token_pending_claims_stream: Array<CurrentTokenPendingClaims>;
    /** An array relationship */
    delegated_staking_activities: Array<DelegatedStakingActivities>;
    /** fetch data from the table: "delegated_staking_activities" using primary key columns */
    delegated_staking_activities_by_pk?: Maybe<DelegatedStakingActivities>;
    /** fetch data from the table in a streaming manner: "delegated_staking_activities" */
    delegated_staking_activities_stream: Array<DelegatedStakingActivities>;
    /** fetch data from the table: "delegated_staking_pool_balances" */
    delegated_staking_pool_balances: Array<DelegatedStakingPoolBalances>;
    /** fetch aggregated fields from the table: "delegated_staking_pool_balances" */
    delegated_staking_pool_balances_aggregate: DelegatedStakingPoolBalancesAggregate;
    /** fetch data from the table: "delegated_staking_pool_balances" using primary key columns */
    delegated_staking_pool_balances_by_pk?: Maybe<DelegatedStakingPoolBalances>;
    /** fetch data from the table in a streaming manner: "delegated_staking_pool_balances" */
    delegated_staking_pool_balances_stream: Array<DelegatedStakingPoolBalances>;
    /** fetch data from the table: "delegated_staking_pools" */
    delegated_staking_pools: Array<DelegatedStakingPools>;
    /** fetch data from the table: "delegated_staking_pools" using primary key columns */
    delegated_staking_pools_by_pk?: Maybe<DelegatedStakingPools>;
    /** fetch data from the table in a streaming manner: "delegated_staking_pools" */
    delegated_staking_pools_stream: Array<DelegatedStakingPools>;
    /** fetch data from the table: "delegator_distinct_pool" */
    delegator_distinct_pool: Array<DelegatorDistinctPool>;
    /** fetch aggregated fields from the table: "delegator_distinct_pool" */
    delegator_distinct_pool_aggregate: DelegatorDistinctPoolAggregate;
    /** fetch data from the table in a streaming manner: "delegator_distinct_pool" */
    delegator_distinct_pool_stream: Array<DelegatorDistinctPool>;
    /** fetch data from the table: "events" */
    events: Array<Events>;
    /** fetch data from the table: "events" using primary key columns */
    events_by_pk?: Maybe<Events>;
    /** fetch data from the table in a streaming manner: "events" */
    events_stream: Array<Events>;
    /** An array relationship */
    fungible_asset_activities: Array<FungibleAssetActivities>;
    /** fetch data from the table: "fungible_asset_activities" using primary key columns */
    fungible_asset_activities_by_pk?: Maybe<FungibleAssetActivities>;
    /** fetch data from the table in a streaming manner: "fungible_asset_activities" */
    fungible_asset_activities_stream: Array<FungibleAssetActivities>;
    /** fetch data from the table: "fungible_asset_metadata" */
    fungible_asset_metadata: Array<FungibleAssetMetadata>;
    /** fetch data from the table: "fungible_asset_metadata" using primary key columns */
    fungible_asset_metadata_by_pk?: Maybe<FungibleAssetMetadata>;
    /** fetch data from the table in a streaming manner: "fungible_asset_metadata" */
    fungible_asset_metadata_stream: Array<FungibleAssetMetadata>;
    /** fetch data from the table: "indexer_status" */
    indexer_status: Array<IndexerStatus>;
    /** fetch data from the table: "indexer_status" using primary key columns */
    indexer_status_by_pk?: Maybe<IndexerStatus>;
    /** fetch data from the table in a streaming manner: "indexer_status" */
    indexer_status_stream: Array<IndexerStatus>;
    /** fetch data from the table: "ledger_infos" */
    ledger_infos: Array<LedgerInfos>;
    /** fetch data from the table: "ledger_infos" using primary key columns */
    ledger_infos_by_pk?: Maybe<LedgerInfos>;
    /** fetch data from the table in a streaming manner: "ledger_infos" */
    ledger_infos_stream: Array<LedgerInfos>;
    /** fetch data from the table: "move_resources" */
    move_resources: Array<MoveResources>;
    /** fetch aggregated fields from the table: "move_resources" */
    move_resources_aggregate: MoveResourcesAggregate;
    /** fetch data from the table in a streaming manner: "move_resources" */
    move_resources_stream: Array<MoveResources>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_auctions" */
    nft_marketplace_v2_current_nft_marketplace_auctions: Array<NftMarketplaceV2CurrentNftMarketplaceAuctions>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_auctions" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_auctions_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceAuctions>;
    /** fetch data from the table in a streaming manner: "nft_marketplace_v2.current_nft_marketplace_auctions" */
    nft_marketplace_v2_current_nft_marketplace_auctions_stream: Array<NftMarketplaceV2CurrentNftMarketplaceAuctions>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_collection_offers" */
    nft_marketplace_v2_current_nft_marketplace_collection_offers: Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffers>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_collection_offers" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_collection_offers_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffers>;
    /** fetch data from the table in a streaming manner: "nft_marketplace_v2.current_nft_marketplace_collection_offers" */
    nft_marketplace_v2_current_nft_marketplace_collection_offers_stream: Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffers>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_listings" */
    nft_marketplace_v2_current_nft_marketplace_listings: Array<NftMarketplaceV2CurrentNftMarketplaceListings>;
    /** fetch aggregated fields from the table: "nft_marketplace_v2.current_nft_marketplace_listings" */
    nft_marketplace_v2_current_nft_marketplace_listings_aggregate: NftMarketplaceV2CurrentNftMarketplaceListingsAggregate;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_listings" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_listings_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceListings>;
    /** fetch data from the table in a streaming manner: "nft_marketplace_v2.current_nft_marketplace_listings" */
    nft_marketplace_v2_current_nft_marketplace_listings_stream: Array<NftMarketplaceV2CurrentNftMarketplaceListings>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_token_offers" */
    nft_marketplace_v2_current_nft_marketplace_token_offers: Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffers>;
    /** fetch data from the table: "nft_marketplace_v2.current_nft_marketplace_token_offers" using primary key columns */
    nft_marketplace_v2_current_nft_marketplace_token_offers_by_pk?: Maybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffers>;
    /** fetch data from the table in a streaming manner: "nft_marketplace_v2.current_nft_marketplace_token_offers" */
    nft_marketplace_v2_current_nft_marketplace_token_offers_stream: Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffers>;
    /** fetch data from the table: "nft_marketplace_v2.nft_marketplace_activities" */
    nft_marketplace_v2_nft_marketplace_activities: Array<NftMarketplaceV2NftMarketplaceActivities>;
    /** fetch data from the table: "nft_marketplace_v2.nft_marketplace_activities" using primary key columns */
    nft_marketplace_v2_nft_marketplace_activities_by_pk?: Maybe<NftMarketplaceV2NftMarketplaceActivities>;
    /** fetch data from the table in a streaming manner: "nft_marketplace_v2.nft_marketplace_activities" */
    nft_marketplace_v2_nft_marketplace_activities_stream: Array<NftMarketplaceV2NftMarketplaceActivities>;
    /** fetch data from the table: "nft_metadata_crawler.parsed_asset_uris" */
    nft_metadata_crawler_parsed_asset_uris: Array<NftMetadataCrawlerParsedAssetUris>;
    /** fetch data from the table: "nft_metadata_crawler.parsed_asset_uris" using primary key columns */
    nft_metadata_crawler_parsed_asset_uris_by_pk?: Maybe<NftMetadataCrawlerParsedAssetUris>;
    /** fetch data from the table in a streaming manner: "nft_metadata_crawler.parsed_asset_uris" */
    nft_metadata_crawler_parsed_asset_uris_stream: Array<NftMetadataCrawlerParsedAssetUris>;
    /** fetch data from the table: "num_active_delegator_per_pool" */
    num_active_delegator_per_pool: Array<NumActiveDelegatorPerPool>;
    /** fetch data from the table in a streaming manner: "num_active_delegator_per_pool" */
    num_active_delegator_per_pool_stream: Array<NumActiveDelegatorPerPool>;
    /** fetch data from the table: "processor_status" */
    processor_status: Array<ProcessorStatus>;
    /** fetch data from the table: "processor_status" using primary key columns */
    processor_status_by_pk?: Maybe<ProcessorStatus>;
    /** fetch data from the table in a streaming manner: "processor_status" */
    processor_status_stream: Array<ProcessorStatus>;
    /** fetch data from the table: "proposal_votes" */
    proposal_votes: Array<ProposalVotes>;
    /** fetch aggregated fields from the table: "proposal_votes" */
    proposal_votes_aggregate: ProposalVotesAggregate;
    /** fetch data from the table: "proposal_votes" using primary key columns */
    proposal_votes_by_pk?: Maybe<ProposalVotes>;
    /** fetch data from the table in a streaming manner: "proposal_votes" */
    proposal_votes_stream: Array<ProposalVotes>;
    /** fetch data from the table: "signatures" */
    signatures: Array<Signatures>;
    /** fetch data from the table: "signatures" using primary key columns */
    signatures_by_pk?: Maybe<Signatures>;
    /** fetch data from the table in a streaming manner: "signatures" */
    signatures_stream: Array<Signatures>;
    /** fetch data from the table: "table_items" */
    table_items: Array<TableItems>;
    /** fetch data from the table: "table_items" using primary key columns */
    table_items_by_pk?: Maybe<TableItems>;
    /** fetch data from the table in a streaming manner: "table_items" */
    table_items_stream: Array<TableItems>;
    /** fetch data from the table: "table_metadatas" */
    table_metadatas: Array<TableMetadatas>;
    /** fetch data from the table: "table_metadatas" using primary key columns */
    table_metadatas_by_pk?: Maybe<TableMetadatas>;
    /** fetch data from the table in a streaming manner: "table_metadatas" */
    table_metadatas_stream: Array<TableMetadatas>;
    /** An array relationship */
    token_activities: Array<TokenActivities>;
    /** An aggregate relationship */
    token_activities_aggregate: TokenActivitiesAggregate;
    /** fetch data from the table: "token_activities" using primary key columns */
    token_activities_by_pk?: Maybe<TokenActivities>;
    /** fetch data from the table in a streaming manner: "token_activities" */
    token_activities_stream: Array<TokenActivities>;
    /** An array relationship */
    token_activities_v2: Array<TokenActivitiesV2>;
    /** An aggregate relationship */
    token_activities_v2_aggregate: TokenActivitiesV2Aggregate;
    /** fetch data from the table: "token_activities_v2" using primary key columns */
    token_activities_v2_by_pk?: Maybe<TokenActivitiesV2>;
    /** fetch data from the table in a streaming manner: "token_activities_v2" */
    token_activities_v2_stream: Array<TokenActivitiesV2>;
    /** fetch data from the table: "token_datas" */
    token_datas: Array<TokenDatas>;
    /** fetch data from the table: "token_datas" using primary key columns */
    token_datas_by_pk?: Maybe<TokenDatas>;
    /** fetch data from the table in a streaming manner: "token_datas" */
    token_datas_stream: Array<TokenDatas>;
    /** fetch data from the table: "token_ownerships" */
    token_ownerships: Array<TokenOwnerships>;
    /** fetch data from the table: "token_ownerships" using primary key columns */
    token_ownerships_by_pk?: Maybe<TokenOwnerships>;
    /** fetch data from the table in a streaming manner: "token_ownerships" */
    token_ownerships_stream: Array<TokenOwnerships>;
    /** fetch data from the table: "tokens" */
    tokens: Array<Tokens>;
    /** fetch data from the table: "tokens" using primary key columns */
    tokens_by_pk?: Maybe<Tokens>;
    /** fetch data from the table in a streaming manner: "tokens" */
    tokens_stream: Array<Tokens>;
    /** fetch data from the table: "user_transactions" */
    user_transactions: Array<UserTransactions>;
    /** fetch data from the table: "user_transactions" using primary key columns */
    user_transactions_by_pk?: Maybe<UserTransactions>;
    /** fetch data from the table in a streaming manner: "user_transactions" */
    user_transactions_stream: Array<UserTransactions>;
};
type SubscriptionRootAccountTransactionsArgs = {
    distinct_on?: InputMaybe<Array<AccountTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AccountTransactionsOrderBy>>;
    where?: InputMaybe<AccountTransactionsBoolExp>;
};
type SubscriptionRootAccountTransactionsAggregateArgs = {
    distinct_on?: InputMaybe<Array<AccountTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AccountTransactionsOrderBy>>;
    where?: InputMaybe<AccountTransactionsBoolExp>;
};
type SubscriptionRootAccountTransactionsByPkArgs = {
    account_address: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootAccountTransactionsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<AccountTransactionsStreamCursorInput>>;
    where?: InputMaybe<AccountTransactionsBoolExp>;
};
type SubscriptionRootAddressEventsSummaryArgs = {
    distinct_on?: InputMaybe<Array<AddressEventsSummarySelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressEventsSummaryOrderBy>>;
    where?: InputMaybe<AddressEventsSummaryBoolExp>;
};
type SubscriptionRootAddressEventsSummaryStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<AddressEventsSummaryStreamCursorInput>>;
    where?: InputMaybe<AddressEventsSummaryBoolExp>;
};
type SubscriptionRootAddressVersionFromEventsArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromEventsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromEventsOrderBy>>;
    where?: InputMaybe<AddressVersionFromEventsBoolExp>;
};
type SubscriptionRootAddressVersionFromEventsAggregateArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromEventsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromEventsOrderBy>>;
    where?: InputMaybe<AddressVersionFromEventsBoolExp>;
};
type SubscriptionRootAddressVersionFromEventsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<AddressVersionFromEventsStreamCursorInput>>;
    where?: InputMaybe<AddressVersionFromEventsBoolExp>;
};
type SubscriptionRootAddressVersionFromMoveResourcesArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromMoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromMoveResourcesOrderBy>>;
    where?: InputMaybe<AddressVersionFromMoveResourcesBoolExp>;
};
type SubscriptionRootAddressVersionFromMoveResourcesAggregateArgs = {
    distinct_on?: InputMaybe<Array<AddressVersionFromMoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<AddressVersionFromMoveResourcesOrderBy>>;
    where?: InputMaybe<AddressVersionFromMoveResourcesBoolExp>;
};
type SubscriptionRootAddressVersionFromMoveResourcesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<AddressVersionFromMoveResourcesStreamCursorInput>>;
    where?: InputMaybe<AddressVersionFromMoveResourcesBoolExp>;
};
type SubscriptionRootBlockMetadataTransactionsArgs = {
    distinct_on?: InputMaybe<Array<BlockMetadataTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<BlockMetadataTransactionsOrderBy>>;
    where?: InputMaybe<BlockMetadataTransactionsBoolExp>;
};
type SubscriptionRootBlockMetadataTransactionsByPkArgs = {
    version: Scalars["bigint"]["input"];
};
type SubscriptionRootBlockMetadataTransactionsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<BlockMetadataTransactionsStreamCursorInput>>;
    where?: InputMaybe<BlockMetadataTransactionsBoolExp>;
};
type SubscriptionRootCoinActivitiesArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
type SubscriptionRootCoinActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CoinActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinActivitiesOrderBy>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
type SubscriptionRootCoinActivitiesByPkArgs = {
    event_account_address: Scalars["String"]["input"];
    event_creation_number: Scalars["bigint"]["input"];
    event_sequence_number: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootCoinActivitiesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CoinActivitiesStreamCursorInput>>;
    where?: InputMaybe<CoinActivitiesBoolExp>;
};
type SubscriptionRootCoinBalancesArgs = {
    distinct_on?: InputMaybe<Array<CoinBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinBalancesOrderBy>>;
    where?: InputMaybe<CoinBalancesBoolExp>;
};
type SubscriptionRootCoinBalancesByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
    owner_address: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootCoinBalancesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CoinBalancesStreamCursorInput>>;
    where?: InputMaybe<CoinBalancesBoolExp>;
};
type SubscriptionRootCoinInfosArgs = {
    distinct_on?: InputMaybe<Array<CoinInfosSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinInfosOrderBy>>;
    where?: InputMaybe<CoinInfosBoolExp>;
};
type SubscriptionRootCoinInfosByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
};
type SubscriptionRootCoinInfosStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CoinInfosStreamCursorInput>>;
    where?: InputMaybe<CoinInfosBoolExp>;
};
type SubscriptionRootCoinSupplyArgs = {
    distinct_on?: InputMaybe<Array<CoinSupplySelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CoinSupplyOrderBy>>;
    where?: InputMaybe<CoinSupplyBoolExp>;
};
type SubscriptionRootCoinSupplyByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootCoinSupplyStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CoinSupplyStreamCursorInput>>;
    where?: InputMaybe<CoinSupplyBoolExp>;
};
type SubscriptionRootCollectionDatasArgs = {
    distinct_on?: InputMaybe<Array<CollectionDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CollectionDatasOrderBy>>;
    where?: InputMaybe<CollectionDatasBoolExp>;
};
type SubscriptionRootCollectionDatasByPkArgs = {
    collection_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootCollectionDatasStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CollectionDatasStreamCursorInput>>;
    where?: InputMaybe<CollectionDatasBoolExp>;
};
type SubscriptionRootCurrentAnsLookupArgs = {
    distinct_on?: InputMaybe<Array<CurrentAnsLookupSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAnsLookupOrderBy>>;
    where?: InputMaybe<CurrentAnsLookupBoolExp>;
};
type SubscriptionRootCurrentAnsLookupByPkArgs = {
    domain: Scalars["String"]["input"];
    subdomain: Scalars["String"]["input"];
};
type SubscriptionRootCurrentAnsLookupStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentAnsLookupStreamCursorInput>>;
    where?: InputMaybe<CurrentAnsLookupBoolExp>;
};
type SubscriptionRootCurrentAnsLookupV2Args = {
    distinct_on?: InputMaybe<Array<CurrentAnsLookupV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAnsLookupV2OrderBy>>;
    where?: InputMaybe<CurrentAnsLookupV2BoolExp>;
};
type SubscriptionRootCurrentAnsLookupV2ByPkArgs = {
    domain: Scalars["String"]["input"];
    subdomain: Scalars["String"]["input"];
    token_standard: Scalars["String"]["input"];
};
type SubscriptionRootCurrentAnsLookupV2StreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentAnsLookupV2StreamCursorInput>>;
    where?: InputMaybe<CurrentAnsLookupV2BoolExp>;
};
type SubscriptionRootCurrentAptosNamesArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
type SubscriptionRootCurrentAptosNamesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
type SubscriptionRootCurrentAptosNamesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentAptosNamesStreamCursorInput>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
type SubscriptionRootCurrentCoinBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentCoinBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCoinBalancesOrderBy>>;
    where?: InputMaybe<CurrentCoinBalancesBoolExp>;
};
type SubscriptionRootCurrentCoinBalancesByPkArgs = {
    coin_type_hash: Scalars["String"]["input"];
    owner_address: Scalars["String"]["input"];
};
type SubscriptionRootCurrentCoinBalancesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentCoinBalancesStreamCursorInput>>;
    where?: InputMaybe<CurrentCoinBalancesBoolExp>;
};
type SubscriptionRootCurrentCollectionDatasArgs = {
    distinct_on?: InputMaybe<Array<CurrentCollectionDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionDatasOrderBy>>;
    where?: InputMaybe<CurrentCollectionDatasBoolExp>;
};
type SubscriptionRootCurrentCollectionDatasByPkArgs = {
    collection_data_id_hash: Scalars["String"]["input"];
};
type SubscriptionRootCurrentCollectionDatasStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentCollectionDatasStreamCursorInput>>;
    where?: InputMaybe<CurrentCollectionDatasBoolExp>;
};
type SubscriptionRootCurrentCollectionOwnershipV2ViewArgs = {
    distinct_on?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewOrderBy>>;
    where?: InputMaybe<CurrentCollectionOwnershipV2ViewBoolExp>;
};
type SubscriptionRootCurrentCollectionOwnershipV2ViewAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionOwnershipV2ViewOrderBy>>;
    where?: InputMaybe<CurrentCollectionOwnershipV2ViewBoolExp>;
};
type SubscriptionRootCurrentCollectionOwnershipV2ViewStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentCollectionOwnershipV2ViewStreamCursorInput>>;
    where?: InputMaybe<CurrentCollectionOwnershipV2ViewBoolExp>;
};
type SubscriptionRootCurrentCollectionsV2Args = {
    distinct_on?: InputMaybe<Array<CurrentCollectionsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentCollectionsV2OrderBy>>;
    where?: InputMaybe<CurrentCollectionsV2BoolExp>;
};
type SubscriptionRootCurrentCollectionsV2ByPkArgs = {
    collection_id: Scalars["String"]["input"];
};
type SubscriptionRootCurrentCollectionsV2StreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentCollectionsV2StreamCursorInput>>;
    where?: InputMaybe<CurrentCollectionsV2BoolExp>;
};
type SubscriptionRootCurrentDelegatedStakingPoolBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentDelegatedStakingPoolBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentDelegatedStakingPoolBalancesOrderBy>>;
    where?: InputMaybe<CurrentDelegatedStakingPoolBalancesBoolExp>;
};
type SubscriptionRootCurrentDelegatedStakingPoolBalancesByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
};
type SubscriptionRootCurrentDelegatedStakingPoolBalancesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentDelegatedStakingPoolBalancesStreamCursorInput>>;
    where?: InputMaybe<CurrentDelegatedStakingPoolBalancesBoolExp>;
};
type SubscriptionRootCurrentDelegatedVoterArgs = {
    distinct_on?: InputMaybe<Array<CurrentDelegatedVoterSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentDelegatedVoterOrderBy>>;
    where?: InputMaybe<CurrentDelegatedVoterBoolExp>;
};
type SubscriptionRootCurrentDelegatedVoterByPkArgs = {
    delegation_pool_address: Scalars["String"]["input"];
    delegator_address: Scalars["String"]["input"];
};
type SubscriptionRootCurrentDelegatedVoterStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentDelegatedVoterStreamCursorInput>>;
    where?: InputMaybe<CurrentDelegatedVoterBoolExp>;
};
type SubscriptionRootCurrentDelegatorBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentDelegatorBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentDelegatorBalancesOrderBy>>;
    where?: InputMaybe<CurrentDelegatorBalancesBoolExp>;
};
type SubscriptionRootCurrentDelegatorBalancesByPkArgs = {
    delegator_address: Scalars["String"]["input"];
    pool_address: Scalars["String"]["input"];
    pool_type: Scalars["String"]["input"];
    table_handle: Scalars["String"]["input"];
};
type SubscriptionRootCurrentDelegatorBalancesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentDelegatorBalancesStreamCursorInput>>;
    where?: InputMaybe<CurrentDelegatorBalancesBoolExp>;
};
type SubscriptionRootCurrentFungibleAssetBalancesArgs = {
    distinct_on?: InputMaybe<Array<CurrentFungibleAssetBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentFungibleAssetBalancesOrderBy>>;
    where?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
};
type SubscriptionRootCurrentFungibleAssetBalancesAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentFungibleAssetBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentFungibleAssetBalancesOrderBy>>;
    where?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
};
type SubscriptionRootCurrentFungibleAssetBalancesByPkArgs = {
    storage_id: Scalars["String"]["input"];
};
type SubscriptionRootCurrentFungibleAssetBalancesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentFungibleAssetBalancesStreamCursorInput>>;
    where?: InputMaybe<CurrentFungibleAssetBalancesBoolExp>;
};
type SubscriptionRootCurrentObjectsArgs = {
    distinct_on?: InputMaybe<Array<CurrentObjectsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentObjectsOrderBy>>;
    where?: InputMaybe<CurrentObjectsBoolExp>;
};
type SubscriptionRootCurrentObjectsByPkArgs = {
    object_address: Scalars["String"]["input"];
};
type SubscriptionRootCurrentObjectsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentObjectsStreamCursorInput>>;
    where?: InputMaybe<CurrentObjectsBoolExp>;
};
type SubscriptionRootCurrentStakingPoolVoterArgs = {
    distinct_on?: InputMaybe<Array<CurrentStakingPoolVoterSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentStakingPoolVoterOrderBy>>;
    where?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
};
type SubscriptionRootCurrentStakingPoolVoterByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
};
type SubscriptionRootCurrentStakingPoolVoterStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentStakingPoolVoterStreamCursorInput>>;
    where?: InputMaybe<CurrentStakingPoolVoterBoolExp>;
};
type SubscriptionRootCurrentTableItemsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTableItemsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTableItemsOrderBy>>;
    where?: InputMaybe<CurrentTableItemsBoolExp>;
};
type SubscriptionRootCurrentTableItemsByPkArgs = {
    key_hash: Scalars["String"]["input"];
    table_handle: Scalars["String"]["input"];
};
type SubscriptionRootCurrentTableItemsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentTableItemsStreamCursorInput>>;
    where?: InputMaybe<CurrentTableItemsBoolExp>;
};
type SubscriptionRootCurrentTokenDatasArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenDatasOrderBy>>;
    where?: InputMaybe<CurrentTokenDatasBoolExp>;
};
type SubscriptionRootCurrentTokenDatasByPkArgs = {
    token_data_id_hash: Scalars["String"]["input"];
};
type SubscriptionRootCurrentTokenDatasStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentTokenDatasStreamCursorInput>>;
    where?: InputMaybe<CurrentTokenDatasBoolExp>;
};
type SubscriptionRootCurrentTokenDatasV2Args = {
    distinct_on?: InputMaybe<Array<CurrentTokenDatasV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenDatasV2OrderBy>>;
    where?: InputMaybe<CurrentTokenDatasV2BoolExp>;
};
type SubscriptionRootCurrentTokenDatasV2ByPkArgs = {
    token_data_id: Scalars["String"]["input"];
};
type SubscriptionRootCurrentTokenDatasV2StreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentTokenDatasV2StreamCursorInput>>;
    where?: InputMaybe<CurrentTokenDatasV2BoolExp>;
};
type SubscriptionRootCurrentTokenOwnershipsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsOrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
type SubscriptionRootCurrentTokenOwnershipsAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsOrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
type SubscriptionRootCurrentTokenOwnershipsByPkArgs = {
    owner_address: Scalars["String"]["input"];
    property_version: Scalars["numeric"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
};
type SubscriptionRootCurrentTokenOwnershipsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentTokenOwnershipsStreamCursorInput>>;
    where?: InputMaybe<CurrentTokenOwnershipsBoolExp>;
};
type SubscriptionRootCurrentTokenOwnershipsV2Args = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
type SubscriptionRootCurrentTokenOwnershipsV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenOwnershipsV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenOwnershipsV2OrderBy>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
type SubscriptionRootCurrentTokenOwnershipsV2ByPkArgs = {
    owner_address: Scalars["String"]["input"];
    property_version_v1: Scalars["numeric"]["input"];
    storage_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type SubscriptionRootCurrentTokenOwnershipsV2StreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentTokenOwnershipsV2StreamCursorInput>>;
    where?: InputMaybe<CurrentTokenOwnershipsV2BoolExp>;
};
type SubscriptionRootCurrentTokenPendingClaimsArgs = {
    distinct_on?: InputMaybe<Array<CurrentTokenPendingClaimsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentTokenPendingClaimsOrderBy>>;
    where?: InputMaybe<CurrentTokenPendingClaimsBoolExp>;
};
type SubscriptionRootCurrentTokenPendingClaimsByPkArgs = {
    from_address: Scalars["String"]["input"];
    property_version: Scalars["numeric"]["input"];
    to_address: Scalars["String"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
};
type SubscriptionRootCurrentTokenPendingClaimsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<CurrentTokenPendingClaimsStreamCursorInput>>;
    where?: InputMaybe<CurrentTokenPendingClaimsBoolExp>;
};
type SubscriptionRootDelegatedStakingActivitiesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingActivitiesOrderBy>>;
    where?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
};
type SubscriptionRootDelegatedStakingActivitiesByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootDelegatedStakingActivitiesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<DelegatedStakingActivitiesStreamCursorInput>>;
    where?: InputMaybe<DelegatedStakingActivitiesBoolExp>;
};
type SubscriptionRootDelegatedStakingPoolBalancesArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingPoolBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingPoolBalancesOrderBy>>;
    where?: InputMaybe<DelegatedStakingPoolBalancesBoolExp>;
};
type SubscriptionRootDelegatedStakingPoolBalancesAggregateArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingPoolBalancesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingPoolBalancesOrderBy>>;
    where?: InputMaybe<DelegatedStakingPoolBalancesBoolExp>;
};
type SubscriptionRootDelegatedStakingPoolBalancesByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootDelegatedStakingPoolBalancesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<DelegatedStakingPoolBalancesStreamCursorInput>>;
    where?: InputMaybe<DelegatedStakingPoolBalancesBoolExp>;
};
type SubscriptionRootDelegatedStakingPoolsArgs = {
    distinct_on?: InputMaybe<Array<DelegatedStakingPoolsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatedStakingPoolsOrderBy>>;
    where?: InputMaybe<DelegatedStakingPoolsBoolExp>;
};
type SubscriptionRootDelegatedStakingPoolsByPkArgs = {
    staking_pool_address: Scalars["String"]["input"];
};
type SubscriptionRootDelegatedStakingPoolsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<DelegatedStakingPoolsStreamCursorInput>>;
    where?: InputMaybe<DelegatedStakingPoolsBoolExp>;
};
type SubscriptionRootDelegatorDistinctPoolArgs = {
    distinct_on?: InputMaybe<Array<DelegatorDistinctPoolSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatorDistinctPoolOrderBy>>;
    where?: InputMaybe<DelegatorDistinctPoolBoolExp>;
};
type SubscriptionRootDelegatorDistinctPoolAggregateArgs = {
    distinct_on?: InputMaybe<Array<DelegatorDistinctPoolSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<DelegatorDistinctPoolOrderBy>>;
    where?: InputMaybe<DelegatorDistinctPoolBoolExp>;
};
type SubscriptionRootDelegatorDistinctPoolStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<DelegatorDistinctPoolStreamCursorInput>>;
    where?: InputMaybe<DelegatorDistinctPoolBoolExp>;
};
type SubscriptionRootEventsArgs = {
    distinct_on?: InputMaybe<Array<EventsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<EventsOrderBy>>;
    where?: InputMaybe<EventsBoolExp>;
};
type SubscriptionRootEventsByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootEventsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<EventsStreamCursorInput>>;
    where?: InputMaybe<EventsBoolExp>;
};
type SubscriptionRootFungibleAssetActivitiesArgs = {
    distinct_on?: InputMaybe<Array<FungibleAssetActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<FungibleAssetActivitiesOrderBy>>;
    where?: InputMaybe<FungibleAssetActivitiesBoolExp>;
};
type SubscriptionRootFungibleAssetActivitiesByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootFungibleAssetActivitiesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<FungibleAssetActivitiesStreamCursorInput>>;
    where?: InputMaybe<FungibleAssetActivitiesBoolExp>;
};
type SubscriptionRootFungibleAssetMetadataArgs = {
    distinct_on?: InputMaybe<Array<FungibleAssetMetadataSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<FungibleAssetMetadataOrderBy>>;
    where?: InputMaybe<FungibleAssetMetadataBoolExp>;
};
type SubscriptionRootFungibleAssetMetadataByPkArgs = {
    asset_type: Scalars["String"]["input"];
};
type SubscriptionRootFungibleAssetMetadataStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<FungibleAssetMetadataStreamCursorInput>>;
    where?: InputMaybe<FungibleAssetMetadataBoolExp>;
};
type SubscriptionRootIndexerStatusArgs = {
    distinct_on?: InputMaybe<Array<IndexerStatusSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<IndexerStatusOrderBy>>;
    where?: InputMaybe<IndexerStatusBoolExp>;
};
type SubscriptionRootIndexerStatusByPkArgs = {
    db: Scalars["String"]["input"];
};
type SubscriptionRootIndexerStatusStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<IndexerStatusStreamCursorInput>>;
    where?: InputMaybe<IndexerStatusBoolExp>;
};
type SubscriptionRootLedgerInfosArgs = {
    distinct_on?: InputMaybe<Array<LedgerInfosSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<LedgerInfosOrderBy>>;
    where?: InputMaybe<LedgerInfosBoolExp>;
};
type SubscriptionRootLedgerInfosByPkArgs = {
    chain_id: Scalars["bigint"]["input"];
};
type SubscriptionRootLedgerInfosStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<LedgerInfosStreamCursorInput>>;
    where?: InputMaybe<LedgerInfosBoolExp>;
};
type SubscriptionRootMoveResourcesArgs = {
    distinct_on?: InputMaybe<Array<MoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<MoveResourcesOrderBy>>;
    where?: InputMaybe<MoveResourcesBoolExp>;
};
type SubscriptionRootMoveResourcesAggregateArgs = {
    distinct_on?: InputMaybe<Array<MoveResourcesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<MoveResourcesOrderBy>>;
    where?: InputMaybe<MoveResourcesBoolExp>;
};
type SubscriptionRootMoveResourcesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<MoveResourcesStreamCursorInput>>;
    where?: InputMaybe<MoveResourcesBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceAuctionsArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceAuctionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceAuctionsOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceAuctionsByPkArgs = {
    listing_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceAuctionsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NftMarketplaceV2CurrentNftMarketplaceAuctionsStreamCursorInput>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersByPkArgs = {
    collection_id: Scalars["String"]["input"];
    collection_offer_id: Scalars["String"]["input"];
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamCursorInput>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsAggregateArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceListingsOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsByPkArgs = {
    listing_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsStreamCursorInput>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffersSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2CurrentNftMarketplaceTokenOffersOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp>;
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersByPkArgs = {
    offer_id: Scalars["String"]["input"];
    token_data_id: Scalars["String"]["input"];
};
type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamCursorInput>>;
    where?: InputMaybe<NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp>;
};
type SubscriptionRootNftMarketplaceV2NftMarketplaceActivitiesArgs = {
    distinct_on?: InputMaybe<Array<NftMarketplaceV2NftMarketplaceActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMarketplaceV2NftMarketplaceActivitiesOrderBy>>;
    where?: InputMaybe<NftMarketplaceV2NftMarketplaceActivitiesBoolExp>;
};
type SubscriptionRootNftMarketplaceV2NftMarketplaceActivitiesByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootNftMarketplaceV2NftMarketplaceActivitiesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NftMarketplaceV2NftMarketplaceActivitiesStreamCursorInput>>;
    where?: InputMaybe<NftMarketplaceV2NftMarketplaceActivitiesBoolExp>;
};
type SubscriptionRootNftMetadataCrawlerParsedAssetUrisArgs = {
    distinct_on?: InputMaybe<Array<NftMetadataCrawlerParsedAssetUrisSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NftMetadataCrawlerParsedAssetUrisOrderBy>>;
    where?: InputMaybe<NftMetadataCrawlerParsedAssetUrisBoolExp>;
};
type SubscriptionRootNftMetadataCrawlerParsedAssetUrisByPkArgs = {
    asset_uri: Scalars["String"]["input"];
};
type SubscriptionRootNftMetadataCrawlerParsedAssetUrisStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NftMetadataCrawlerParsedAssetUrisStreamCursorInput>>;
    where?: InputMaybe<NftMetadataCrawlerParsedAssetUrisBoolExp>;
};
type SubscriptionRootNumActiveDelegatorPerPoolArgs = {
    distinct_on?: InputMaybe<Array<NumActiveDelegatorPerPoolSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<NumActiveDelegatorPerPoolOrderBy>>;
    where?: InputMaybe<NumActiveDelegatorPerPoolBoolExp>;
};
type SubscriptionRootNumActiveDelegatorPerPoolStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<NumActiveDelegatorPerPoolStreamCursorInput>>;
    where?: InputMaybe<NumActiveDelegatorPerPoolBoolExp>;
};
type SubscriptionRootProcessorStatusArgs = {
    distinct_on?: InputMaybe<Array<ProcessorStatusSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<ProcessorStatusOrderBy>>;
    where?: InputMaybe<ProcessorStatusBoolExp>;
};
type SubscriptionRootProcessorStatusByPkArgs = {
    processor: Scalars["String"]["input"];
};
type SubscriptionRootProcessorStatusStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<ProcessorStatusStreamCursorInput>>;
    where?: InputMaybe<ProcessorStatusBoolExp>;
};
type SubscriptionRootProposalVotesArgs = {
    distinct_on?: InputMaybe<Array<ProposalVotesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<ProposalVotesOrderBy>>;
    where?: InputMaybe<ProposalVotesBoolExp>;
};
type SubscriptionRootProposalVotesAggregateArgs = {
    distinct_on?: InputMaybe<Array<ProposalVotesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<ProposalVotesOrderBy>>;
    where?: InputMaybe<ProposalVotesBoolExp>;
};
type SubscriptionRootProposalVotesByPkArgs = {
    proposal_id: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
    voter_address: Scalars["String"]["input"];
};
type SubscriptionRootProposalVotesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<ProposalVotesStreamCursorInput>>;
    where?: InputMaybe<ProposalVotesBoolExp>;
};
type SubscriptionRootSignaturesArgs = {
    distinct_on?: InputMaybe<Array<SignaturesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<SignaturesOrderBy>>;
    where?: InputMaybe<SignaturesBoolExp>;
};
type SubscriptionRootSignaturesByPkArgs = {
    is_sender_primary: Scalars["Boolean"]["input"];
    multi_agent_index: Scalars["bigint"]["input"];
    multi_sig_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootSignaturesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<SignaturesStreamCursorInput>>;
    where?: InputMaybe<SignaturesBoolExp>;
};
type SubscriptionRootTableItemsArgs = {
    distinct_on?: InputMaybe<Array<TableItemsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TableItemsOrderBy>>;
    where?: InputMaybe<TableItemsBoolExp>;
};
type SubscriptionRootTableItemsByPkArgs = {
    transaction_version: Scalars["bigint"]["input"];
    write_set_change_index: Scalars["bigint"]["input"];
};
type SubscriptionRootTableItemsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TableItemsStreamCursorInput>>;
    where?: InputMaybe<TableItemsBoolExp>;
};
type SubscriptionRootTableMetadatasArgs = {
    distinct_on?: InputMaybe<Array<TableMetadatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TableMetadatasOrderBy>>;
    where?: InputMaybe<TableMetadatasBoolExp>;
};
type SubscriptionRootTableMetadatasByPkArgs = {
    handle: Scalars["String"]["input"];
};
type SubscriptionRootTableMetadatasStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TableMetadatasStreamCursorInput>>;
    where?: InputMaybe<TableMetadatasBoolExp>;
};
type SubscriptionRootTokenActivitiesArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
type SubscriptionRootTokenActivitiesAggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesOrderBy>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
type SubscriptionRootTokenActivitiesByPkArgs = {
    event_account_address: Scalars["String"]["input"];
    event_creation_number: Scalars["bigint"]["input"];
    event_sequence_number: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootTokenActivitiesStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TokenActivitiesStreamCursorInput>>;
    where?: InputMaybe<TokenActivitiesBoolExp>;
};
type SubscriptionRootTokenActivitiesV2Args = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
type SubscriptionRootTokenActivitiesV2AggregateArgs = {
    distinct_on?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenActivitiesV2OrderBy>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
type SubscriptionRootTokenActivitiesV2ByPkArgs = {
    event_index: Scalars["bigint"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootTokenActivitiesV2StreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TokenActivitiesV2StreamCursorInput>>;
    where?: InputMaybe<TokenActivitiesV2BoolExp>;
};
type SubscriptionRootTokenDatasArgs = {
    distinct_on?: InputMaybe<Array<TokenDatasSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenDatasOrderBy>>;
    where?: InputMaybe<TokenDatasBoolExp>;
};
type SubscriptionRootTokenDatasByPkArgs = {
    token_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootTokenDatasStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TokenDatasStreamCursorInput>>;
    where?: InputMaybe<TokenDatasBoolExp>;
};
type SubscriptionRootTokenOwnershipsArgs = {
    distinct_on?: InputMaybe<Array<TokenOwnershipsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokenOwnershipsOrderBy>>;
    where?: InputMaybe<TokenOwnershipsBoolExp>;
};
type SubscriptionRootTokenOwnershipsByPkArgs = {
    property_version: Scalars["numeric"]["input"];
    table_handle: Scalars["String"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootTokenOwnershipsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TokenOwnershipsStreamCursorInput>>;
    where?: InputMaybe<TokenOwnershipsBoolExp>;
};
type SubscriptionRootTokensArgs = {
    distinct_on?: InputMaybe<Array<TokensSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<TokensOrderBy>>;
    where?: InputMaybe<TokensBoolExp>;
};
type SubscriptionRootTokensByPkArgs = {
    property_version: Scalars["numeric"]["input"];
    token_data_id_hash: Scalars["String"]["input"];
    transaction_version: Scalars["bigint"]["input"];
};
type SubscriptionRootTokensStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<TokensStreamCursorInput>>;
    where?: InputMaybe<TokensBoolExp>;
};
type SubscriptionRootUserTransactionsArgs = {
    distinct_on?: InputMaybe<Array<UserTransactionsSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<UserTransactionsOrderBy>>;
    where?: InputMaybe<UserTransactionsBoolExp>;
};
type SubscriptionRootUserTransactionsByPkArgs = {
    version: Scalars["bigint"]["input"];
};
type SubscriptionRootUserTransactionsStreamArgs = {
    batch_size: Scalars["Int"]["input"];
    cursor: Array<InputMaybe<UserTransactionsStreamCursorInput>>;
    where?: InputMaybe<UserTransactionsBoolExp>;
};
/** columns and relationships of "table_items" */
type TableItems = {
    decoded_key: Scalars["jsonb"]["output"];
    decoded_value?: Maybe<Scalars["jsonb"]["output"]>;
    key: Scalars["String"]["output"];
    table_handle: Scalars["String"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    write_set_change_index: Scalars["bigint"]["output"];
};
/** columns and relationships of "table_items" */
type TableItemsDecodedKeyArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** columns and relationships of "table_items" */
type TableItemsDecodedValueArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "table_items". All fields are combined with a logical 'AND'. */
type TableItemsBoolExp = {
    _and?: InputMaybe<Array<TableItemsBoolExp>>;
    _not?: InputMaybe<TableItemsBoolExp>;
    _or?: InputMaybe<Array<TableItemsBoolExp>>;
    decoded_key?: InputMaybe<JsonbComparisonExp>;
    decoded_value?: InputMaybe<JsonbComparisonExp>;
    key?: InputMaybe<StringComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    write_set_change_index?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "table_items". */
type TableItemsOrderBy = {
    decoded_key?: InputMaybe<OrderBy>;
    decoded_value?: InputMaybe<OrderBy>;
    key?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    write_set_change_index?: InputMaybe<OrderBy>;
};
/** select columns of table "table_items" */
declare enum TableItemsSelectColumn {
    /** column name */
    DecodedKey = "decoded_key",
    /** column name */
    DecodedValue = "decoded_value",
    /** column name */
    Key = "key",
    /** column name */
    TableHandle = "table_handle",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    WriteSetChangeIndex = "write_set_change_index"
}
/** Streaming cursor of the table "table_items" */
type TableItemsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TableItemsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TableItemsStreamCursorValueInput = {
    decoded_key?: InputMaybe<Scalars["jsonb"]["input"]>;
    decoded_value?: InputMaybe<Scalars["jsonb"]["input"]>;
    key?: InputMaybe<Scalars["String"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    write_set_change_index?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "table_metadatas" */
type TableMetadatas = {
    handle: Scalars["String"]["output"];
    key_type: Scalars["String"]["output"];
    value_type: Scalars["String"]["output"];
};
/** Boolean expression to filter rows from the table "table_metadatas". All fields are combined with a logical 'AND'. */
type TableMetadatasBoolExp = {
    _and?: InputMaybe<Array<TableMetadatasBoolExp>>;
    _not?: InputMaybe<TableMetadatasBoolExp>;
    _or?: InputMaybe<Array<TableMetadatasBoolExp>>;
    handle?: InputMaybe<StringComparisonExp>;
    key_type?: InputMaybe<StringComparisonExp>;
    value_type?: InputMaybe<StringComparisonExp>;
};
/** Ordering options when selecting data from "table_metadatas". */
type TableMetadatasOrderBy = {
    handle?: InputMaybe<OrderBy>;
    key_type?: InputMaybe<OrderBy>;
    value_type?: InputMaybe<OrderBy>;
};
/** select columns of table "table_metadatas" */
declare enum TableMetadatasSelectColumn {
    /** column name */
    Handle = "handle",
    /** column name */
    KeyType = "key_type",
    /** column name */
    ValueType = "value_type"
}
/** Streaming cursor of the table "table_metadatas" */
type TableMetadatasStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TableMetadatasStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TableMetadatasStreamCursorValueInput = {
    handle?: InputMaybe<Scalars["String"]["input"]>;
    key_type?: InputMaybe<Scalars["String"]["input"]>;
    value_type?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to compare columns of type "timestamp". All fields are combined with logical 'AND'. */
type TimestampComparisonExp = {
    _eq?: InputMaybe<Scalars["timestamp"]["input"]>;
    _gt?: InputMaybe<Scalars["timestamp"]["input"]>;
    _gte?: InputMaybe<Scalars["timestamp"]["input"]>;
    _in?: InputMaybe<Array<Scalars["timestamp"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["timestamp"]["input"]>;
    _lte?: InputMaybe<Scalars["timestamp"]["input"]>;
    _neq?: InputMaybe<Scalars["timestamp"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["timestamp"]["input"]>>;
};
/** Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'. */
type TimestamptzComparisonExp = {
    _eq?: InputMaybe<Scalars["timestamptz"]["input"]>;
    _gt?: InputMaybe<Scalars["timestamptz"]["input"]>;
    _gte?: InputMaybe<Scalars["timestamptz"]["input"]>;
    _in?: InputMaybe<Array<Scalars["timestamptz"]["input"]>>;
    _is_null?: InputMaybe<Scalars["Boolean"]["input"]>;
    _lt?: InputMaybe<Scalars["timestamptz"]["input"]>;
    _lte?: InputMaybe<Scalars["timestamptz"]["input"]>;
    _neq?: InputMaybe<Scalars["timestamptz"]["input"]>;
    _nin?: InputMaybe<Array<Scalars["timestamptz"]["input"]>>;
};
/** columns and relationships of "token_activities" */
type TokenActivities = {
    /** An array relationship */
    aptos_names_owner: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    aptos_names_owner_aggregate: CurrentAptosNamesAggregate;
    /** An array relationship */
    aptos_names_to: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    aptos_names_to_aggregate: CurrentAptosNamesAggregate;
    coin_amount?: Maybe<Scalars["numeric"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatas>;
    event_account_address: Scalars["String"]["output"];
    event_creation_number: Scalars["bigint"]["output"];
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number: Scalars["bigint"]["output"];
    from_address?: Maybe<Scalars["String"]["output"]>;
    name: Scalars["String"]["output"];
    property_version: Scalars["numeric"]["output"];
    to_address?: Maybe<Scalars["String"]["output"]>;
    token_amount: Scalars["numeric"]["output"];
    token_data_id_hash: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    transfer_type: Scalars["String"]["output"];
};
/** columns and relationships of "token_activities" */
type TokenActivitiesAptosNamesOwnerArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "token_activities" */
type TokenActivitiesAptosNamesOwnerAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "token_activities" */
type TokenActivitiesAptosNamesToArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "token_activities" */
type TokenActivitiesAptosNamesToAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** aggregated selection of "token_activities" */
type TokenActivitiesAggregate = {
    aggregate?: Maybe<TokenActivitiesAggregateFields>;
    nodes: Array<TokenActivities>;
};
type TokenActivitiesAggregateBoolExp = {
    count?: InputMaybe<TokenActivitiesAggregateBoolExpCount>;
};
type TokenActivitiesAggregateBoolExpCount = {
    arguments?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<TokenActivitiesBoolExp>;
    predicate: IntComparisonExp;
};
/** aggregate fields of "token_activities" */
type TokenActivitiesAggregateFields = {
    avg?: Maybe<TokenActivitiesAvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<TokenActivitiesMaxFields>;
    min?: Maybe<TokenActivitiesMinFields>;
    stddev?: Maybe<TokenActivitiesStddevFields>;
    stddev_pop?: Maybe<TokenActivitiesStddevPopFields>;
    stddev_samp?: Maybe<TokenActivitiesStddevSampFields>;
    sum?: Maybe<TokenActivitiesSumFields>;
    var_pop?: Maybe<TokenActivitiesVarPopFields>;
    var_samp?: Maybe<TokenActivitiesVarSampFields>;
    variance?: Maybe<TokenActivitiesVarianceFields>;
};
/** aggregate fields of "token_activities" */
type TokenActivitiesAggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<TokenActivitiesSelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** order by aggregate values of table "token_activities" */
type TokenActivitiesAggregateOrderBy = {
    avg?: InputMaybe<TokenActivitiesAvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<TokenActivitiesMaxOrderBy>;
    min?: InputMaybe<TokenActivitiesMinOrderBy>;
    stddev?: InputMaybe<TokenActivitiesStddevOrderBy>;
    stddev_pop?: InputMaybe<TokenActivitiesStddevPopOrderBy>;
    stddev_samp?: InputMaybe<TokenActivitiesStddevSampOrderBy>;
    sum?: InputMaybe<TokenActivitiesSumOrderBy>;
    var_pop?: InputMaybe<TokenActivitiesVarPopOrderBy>;
    var_samp?: InputMaybe<TokenActivitiesVarSampOrderBy>;
    variance?: InputMaybe<TokenActivitiesVarianceOrderBy>;
};
/** aggregate avg on columns */
type TokenActivitiesAvgFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by avg() on columns of table "token_activities" */
type TokenActivitiesAvgOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "token_activities". All fields are combined with a logical 'AND'. */
type TokenActivitiesBoolExp = {
    _and?: InputMaybe<Array<TokenActivitiesBoolExp>>;
    _not?: InputMaybe<TokenActivitiesBoolExp>;
    _or?: InputMaybe<Array<TokenActivitiesBoolExp>>;
    aptos_names_owner?: InputMaybe<CurrentAptosNamesBoolExp>;
    aptos_names_owner_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    aptos_names_to?: InputMaybe<CurrentAptosNamesBoolExp>;
    aptos_names_to_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    coin_amount?: InputMaybe<NumericComparisonExp>;
    coin_type?: InputMaybe<StringComparisonExp>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasBoolExp>;
    event_account_address?: InputMaybe<StringComparisonExp>;
    event_creation_number?: InputMaybe<BigintComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    event_sequence_number?: InputMaybe<BigintComparisonExp>;
    from_address?: InputMaybe<StringComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    property_version?: InputMaybe<NumericComparisonExp>;
    to_address?: InputMaybe<StringComparisonExp>;
    token_amount?: InputMaybe<NumericComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    transfer_type?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type TokenActivitiesMaxFields = {
    coin_amount?: Maybe<Scalars["numeric"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_data_id_hash?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    event_account_address?: Maybe<Scalars["String"]["output"]>;
    event_creation_number?: Maybe<Scalars["bigint"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number?: Maybe<Scalars["bigint"]["output"]>;
    from_address?: Maybe<Scalars["String"]["output"]>;
    name?: Maybe<Scalars["String"]["output"]>;
    property_version?: Maybe<Scalars["numeric"]["output"]>;
    to_address?: Maybe<Scalars["String"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    token_data_id_hash?: Maybe<Scalars["String"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    transfer_type?: Maybe<Scalars["String"]["output"]>;
};
/** order by max() on columns of table "token_activities" */
type TokenActivitiesMaxOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    transfer_type?: InputMaybe<OrderBy>;
};
/** aggregate min on columns */
type TokenActivitiesMinFields = {
    coin_amount?: Maybe<Scalars["numeric"]["output"]>;
    coin_type?: Maybe<Scalars["String"]["output"]>;
    collection_data_id_hash?: Maybe<Scalars["String"]["output"]>;
    collection_name?: Maybe<Scalars["String"]["output"]>;
    creator_address?: Maybe<Scalars["String"]["output"]>;
    event_account_address?: Maybe<Scalars["String"]["output"]>;
    event_creation_number?: Maybe<Scalars["bigint"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number?: Maybe<Scalars["bigint"]["output"]>;
    from_address?: Maybe<Scalars["String"]["output"]>;
    name?: Maybe<Scalars["String"]["output"]>;
    property_version?: Maybe<Scalars["numeric"]["output"]>;
    to_address?: Maybe<Scalars["String"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    token_data_id_hash?: Maybe<Scalars["String"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    transfer_type?: Maybe<Scalars["String"]["output"]>;
};
/** order by min() on columns of table "token_activities" */
type TokenActivitiesMinOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    transfer_type?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "token_activities". */
type TokenActivitiesOrderBy = {
    aptos_names_owner_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    aptos_names_to_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    coin_amount?: InputMaybe<OrderBy>;
    coin_type?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasOrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    transfer_type?: InputMaybe<OrderBy>;
};
/** select columns of table "token_activities" */
declare enum TokenActivitiesSelectColumn {
    /** column name */
    CoinAmount = "coin_amount",
    /** column name */
    CoinType = "coin_type",
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    EventAccountAddress = "event_account_address",
    /** column name */
    EventCreationNumber = "event_creation_number",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    EventSequenceNumber = "event_sequence_number",
    /** column name */
    FromAddress = "from_address",
    /** column name */
    Name = "name",
    /** column name */
    PropertyVersion = "property_version",
    /** column name */
    ToAddress = "to_address",
    /** column name */
    TokenAmount = "token_amount",
    /** column name */
    TokenDataIdHash = "token_data_id_hash",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    TransferType = "transfer_type"
}
/** aggregate stddev on columns */
type TokenActivitiesStddevFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev() on columns of table "token_activities" */
type TokenActivitiesStddevOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_pop on columns */
type TokenActivitiesStddevPopFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_pop() on columns of table "token_activities" */
type TokenActivitiesStddevPopOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_samp on columns */
type TokenActivitiesStddevSampFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_samp() on columns of table "token_activities" */
type TokenActivitiesStddevSampOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "token_activities" */
type TokenActivitiesStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TokenActivitiesStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TokenActivitiesStreamCursorValueInput = {
    coin_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    coin_type?: InputMaybe<Scalars["String"]["input"]>;
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    event_account_address?: InputMaybe<Scalars["String"]["input"]>;
    event_creation_number?: InputMaybe<Scalars["bigint"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    event_sequence_number?: InputMaybe<Scalars["bigint"]["input"]>;
    from_address?: InputMaybe<Scalars["String"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    to_address?: InputMaybe<Scalars["String"]["input"]>;
    token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    transfer_type?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type TokenActivitiesSumFields = {
    coin_amount?: Maybe<Scalars["numeric"]["output"]>;
    event_creation_number?: Maybe<Scalars["bigint"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    event_sequence_number?: Maybe<Scalars["bigint"]["output"]>;
    property_version?: Maybe<Scalars["numeric"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** order by sum() on columns of table "token_activities" */
type TokenActivitiesSumOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "token_activities_v2" */
type TokenActivitiesV2 = {
    after_value?: Maybe<Scalars["String"]["output"]>;
    /** An array relationship */
    aptos_names_from: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    aptos_names_from_aggregate: CurrentAptosNamesAggregate;
    /** An array relationship */
    aptos_names_to: Array<CurrentAptosNames>;
    /** An aggregate relationship */
    aptos_names_to_aggregate: CurrentAptosNamesAggregate;
    before_value?: Maybe<Scalars["String"]["output"]>;
    /** An object relationship */
    current_token_data?: Maybe<CurrentTokenDatasV2>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_account_address: Scalars["String"]["output"];
    event_index: Scalars["bigint"]["output"];
    from_address?: Maybe<Scalars["String"]["output"]>;
    is_fungible_v2?: Maybe<Scalars["Boolean"]["output"]>;
    property_version_v1: Scalars["numeric"]["output"];
    to_address?: Maybe<Scalars["String"]["output"]>;
    token_amount: Scalars["numeric"]["output"];
    token_data_id: Scalars["String"]["output"];
    token_standard: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    type: Scalars["String"]["output"];
};
/** columns and relationships of "token_activities_v2" */
type TokenActivitiesV2AptosNamesFromArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "token_activities_v2" */
type TokenActivitiesV2AptosNamesFromAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "token_activities_v2" */
type TokenActivitiesV2AptosNamesToArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** columns and relationships of "token_activities_v2" */
type TokenActivitiesV2AptosNamesToAggregateArgs = {
    distinct_on?: InputMaybe<Array<CurrentAptosNamesSelectColumn>>;
    limit?: InputMaybe<Scalars["Int"]["input"]>;
    offset?: InputMaybe<Scalars["Int"]["input"]>;
    order_by?: InputMaybe<Array<CurrentAptosNamesOrderBy>>;
    where?: InputMaybe<CurrentAptosNamesBoolExp>;
};
/** aggregated selection of "token_activities_v2" */
type TokenActivitiesV2Aggregate = {
    aggregate?: Maybe<TokenActivitiesV2AggregateFields>;
    nodes: Array<TokenActivitiesV2>;
};
type TokenActivitiesV2AggregateBoolExp = {
    bool_and?: InputMaybe<TokenActivitiesV2AggregateBoolExpBoolAnd>;
    bool_or?: InputMaybe<TokenActivitiesV2AggregateBoolExpBoolOr>;
    count?: InputMaybe<TokenActivitiesV2AggregateBoolExpCount>;
};
type TokenActivitiesV2AggregateBoolExpBoolAnd = {
    arguments: TokenActivitiesV2SelectColumnTokenActivitiesV2AggregateBoolExpBoolAndArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<TokenActivitiesV2BoolExp>;
    predicate: BooleanComparisonExp;
};
type TokenActivitiesV2AggregateBoolExpBoolOr = {
    arguments: TokenActivitiesV2SelectColumnTokenActivitiesV2AggregateBoolExpBoolOrArgumentsColumns;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<TokenActivitiesV2BoolExp>;
    predicate: BooleanComparisonExp;
};
type TokenActivitiesV2AggregateBoolExpCount = {
    arguments?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
    filter?: InputMaybe<TokenActivitiesV2BoolExp>;
    predicate: IntComparisonExp;
};
/** aggregate fields of "token_activities_v2" */
type TokenActivitiesV2AggregateFields = {
    avg?: Maybe<TokenActivitiesV2AvgFields>;
    count: Scalars["Int"]["output"];
    max?: Maybe<TokenActivitiesV2MaxFields>;
    min?: Maybe<TokenActivitiesV2MinFields>;
    stddev?: Maybe<TokenActivitiesV2StddevFields>;
    stddev_pop?: Maybe<TokenActivitiesV2StddevPopFields>;
    stddev_samp?: Maybe<TokenActivitiesV2StddevSampFields>;
    sum?: Maybe<TokenActivitiesV2SumFields>;
    var_pop?: Maybe<TokenActivitiesV2VarPopFields>;
    var_samp?: Maybe<TokenActivitiesV2VarSampFields>;
    variance?: Maybe<TokenActivitiesV2VarianceFields>;
};
/** aggregate fields of "token_activities_v2" */
type TokenActivitiesV2AggregateFieldsCountArgs = {
    columns?: InputMaybe<Array<TokenActivitiesV2SelectColumn>>;
    distinct?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** order by aggregate values of table "token_activities_v2" */
type TokenActivitiesV2AggregateOrderBy = {
    avg?: InputMaybe<TokenActivitiesV2AvgOrderBy>;
    count?: InputMaybe<OrderBy>;
    max?: InputMaybe<TokenActivitiesV2MaxOrderBy>;
    min?: InputMaybe<TokenActivitiesV2MinOrderBy>;
    stddev?: InputMaybe<TokenActivitiesV2StddevOrderBy>;
    stddev_pop?: InputMaybe<TokenActivitiesV2StddevPopOrderBy>;
    stddev_samp?: InputMaybe<TokenActivitiesV2StddevSampOrderBy>;
    sum?: InputMaybe<TokenActivitiesV2SumOrderBy>;
    var_pop?: InputMaybe<TokenActivitiesV2VarPopOrderBy>;
    var_samp?: InputMaybe<TokenActivitiesV2VarSampOrderBy>;
    variance?: InputMaybe<TokenActivitiesV2VarianceOrderBy>;
};
/** aggregate avg on columns */
type TokenActivitiesV2AvgFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by avg() on columns of table "token_activities_v2" */
type TokenActivitiesV2AvgOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Boolean expression to filter rows from the table "token_activities_v2". All fields are combined with a logical 'AND'. */
type TokenActivitiesV2BoolExp = {
    _and?: InputMaybe<Array<TokenActivitiesV2BoolExp>>;
    _not?: InputMaybe<TokenActivitiesV2BoolExp>;
    _or?: InputMaybe<Array<TokenActivitiesV2BoolExp>>;
    after_value?: InputMaybe<StringComparisonExp>;
    aptos_names_from?: InputMaybe<CurrentAptosNamesBoolExp>;
    aptos_names_from_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    aptos_names_to?: InputMaybe<CurrentAptosNamesBoolExp>;
    aptos_names_to_aggregate?: InputMaybe<CurrentAptosNamesAggregateBoolExp>;
    before_value?: InputMaybe<StringComparisonExp>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2BoolExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    event_account_address?: InputMaybe<StringComparisonExp>;
    event_index?: InputMaybe<BigintComparisonExp>;
    from_address?: InputMaybe<StringComparisonExp>;
    is_fungible_v2?: InputMaybe<BooleanComparisonExp>;
    property_version_v1?: InputMaybe<NumericComparisonExp>;
    to_address?: InputMaybe<StringComparisonExp>;
    token_amount?: InputMaybe<NumericComparisonExp>;
    token_data_id?: InputMaybe<StringComparisonExp>;
    token_standard?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    type?: InputMaybe<StringComparisonExp>;
};
/** aggregate max on columns */
type TokenActivitiesV2MaxFields = {
    after_value?: Maybe<Scalars["String"]["output"]>;
    before_value?: Maybe<Scalars["String"]["output"]>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_account_address?: Maybe<Scalars["String"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    from_address?: Maybe<Scalars["String"]["output"]>;
    property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
    to_address?: Maybe<Scalars["String"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    type?: Maybe<Scalars["String"]["output"]>;
};
/** order by max() on columns of table "token_activities_v2" */
type TokenActivitiesV2MaxOrderBy = {
    after_value?: InputMaybe<OrderBy>;
    before_value?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** aggregate min on columns */
type TokenActivitiesV2MinFields = {
    after_value?: Maybe<Scalars["String"]["output"]>;
    before_value?: Maybe<Scalars["String"]["output"]>;
    entry_function_id_str?: Maybe<Scalars["String"]["output"]>;
    event_account_address?: Maybe<Scalars["String"]["output"]>;
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    from_address?: Maybe<Scalars["String"]["output"]>;
    property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
    to_address?: Maybe<Scalars["String"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    token_data_id?: Maybe<Scalars["String"]["output"]>;
    token_standard?: Maybe<Scalars["String"]["output"]>;
    transaction_timestamp?: Maybe<Scalars["timestamp"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
    type?: Maybe<Scalars["String"]["output"]>;
};
/** order by min() on columns of table "token_activities_v2" */
type TokenActivitiesV2MinOrderBy = {
    after_value?: InputMaybe<OrderBy>;
    before_value?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** Ordering options when selecting data from "token_activities_v2". */
type TokenActivitiesV2OrderBy = {
    after_value?: InputMaybe<OrderBy>;
    aptos_names_from_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    aptos_names_to_aggregate?: InputMaybe<CurrentAptosNamesAggregateOrderBy>;
    before_value?: InputMaybe<OrderBy>;
    current_token_data?: InputMaybe<CurrentTokenDatasV2OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    event_account_address?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    from_address?: InputMaybe<OrderBy>;
    is_fungible_v2?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    to_address?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    token_data_id?: InputMaybe<OrderBy>;
    token_standard?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    type?: InputMaybe<OrderBy>;
};
/** select columns of table "token_activities_v2" */
declare enum TokenActivitiesV2SelectColumn {
    /** column name */
    AfterValue = "after_value",
    /** column name */
    BeforeValue = "before_value",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    EventAccountAddress = "event_account_address",
    /** column name */
    EventIndex = "event_index",
    /** column name */
    FromAddress = "from_address",
    /** column name */
    IsFungibleV2 = "is_fungible_v2",
    /** column name */
    PropertyVersionV1 = "property_version_v1",
    /** column name */
    ToAddress = "to_address",
    /** column name */
    TokenAmount = "token_amount",
    /** column name */
    TokenDataId = "token_data_id",
    /** column name */
    TokenStandard = "token_standard",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    Type = "type"
}
/** select "token_activities_v2_aggregate_bool_exp_bool_and_arguments_columns" columns of table "token_activities_v2" */
declare enum TokenActivitiesV2SelectColumnTokenActivitiesV2AggregateBoolExpBoolAndArgumentsColumns {
    /** column name */
    IsFungibleV2 = "is_fungible_v2"
}
/** select "token_activities_v2_aggregate_bool_exp_bool_or_arguments_columns" columns of table "token_activities_v2" */
declare enum TokenActivitiesV2SelectColumnTokenActivitiesV2AggregateBoolExpBoolOrArgumentsColumns {
    /** column name */
    IsFungibleV2 = "is_fungible_v2"
}
/** aggregate stddev on columns */
type TokenActivitiesV2StddevFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev() on columns of table "token_activities_v2" */
type TokenActivitiesV2StddevOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_pop on columns */
type TokenActivitiesV2StddevPopFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_pop() on columns of table "token_activities_v2" */
type TokenActivitiesV2StddevPopOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate stddev_samp on columns */
type TokenActivitiesV2StddevSampFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by stddev_samp() on columns of table "token_activities_v2" */
type TokenActivitiesV2StddevSampOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** Streaming cursor of the table "token_activities_v2" */
type TokenActivitiesV2StreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TokenActivitiesV2StreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TokenActivitiesV2StreamCursorValueInput = {
    after_value?: InputMaybe<Scalars["String"]["input"]>;
    before_value?: InputMaybe<Scalars["String"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    event_account_address?: InputMaybe<Scalars["String"]["input"]>;
    event_index?: InputMaybe<Scalars["bigint"]["input"]>;
    from_address?: InputMaybe<Scalars["String"]["input"]>;
    is_fungible_v2?: InputMaybe<Scalars["Boolean"]["input"]>;
    property_version_v1?: InputMaybe<Scalars["numeric"]["input"]>;
    to_address?: InputMaybe<Scalars["String"]["input"]>;
    token_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id?: InputMaybe<Scalars["String"]["input"]>;
    token_standard?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    type?: InputMaybe<Scalars["String"]["input"]>;
};
/** aggregate sum on columns */
type TokenActivitiesV2SumFields = {
    event_index?: Maybe<Scalars["bigint"]["output"]>;
    property_version_v1?: Maybe<Scalars["numeric"]["output"]>;
    token_amount?: Maybe<Scalars["numeric"]["output"]>;
    transaction_version?: Maybe<Scalars["bigint"]["output"]>;
};
/** order by sum() on columns of table "token_activities_v2" */
type TokenActivitiesV2SumOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate var_pop on columns */
type TokenActivitiesV2VarPopFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_pop() on columns of table "token_activities_v2" */
type TokenActivitiesV2VarPopOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate var_samp on columns */
type TokenActivitiesV2VarSampFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_samp() on columns of table "token_activities_v2" */
type TokenActivitiesV2VarSampOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate variance on columns */
type TokenActivitiesV2VarianceFields = {
    event_index?: Maybe<Scalars["Float"]["output"]>;
    property_version_v1?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by variance() on columns of table "token_activities_v2" */
type TokenActivitiesV2VarianceOrderBy = {
    event_index?: InputMaybe<OrderBy>;
    property_version_v1?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate var_pop on columns */
type TokenActivitiesVarPopFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_pop() on columns of table "token_activities" */
type TokenActivitiesVarPopOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate var_samp on columns */
type TokenActivitiesVarSampFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by var_samp() on columns of table "token_activities" */
type TokenActivitiesVarSampOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** aggregate variance on columns */
type TokenActivitiesVarianceFields = {
    coin_amount?: Maybe<Scalars["Float"]["output"]>;
    event_creation_number?: Maybe<Scalars["Float"]["output"]>;
    event_index?: Maybe<Scalars["Float"]["output"]>;
    event_sequence_number?: Maybe<Scalars["Float"]["output"]>;
    property_version?: Maybe<Scalars["Float"]["output"]>;
    token_amount?: Maybe<Scalars["Float"]["output"]>;
    transaction_version?: Maybe<Scalars["Float"]["output"]>;
};
/** order by variance() on columns of table "token_activities" */
type TokenActivitiesVarianceOrderBy = {
    coin_amount?: InputMaybe<OrderBy>;
    event_creation_number?: InputMaybe<OrderBy>;
    event_index?: InputMaybe<OrderBy>;
    event_sequence_number?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_amount?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** columns and relationships of "token_datas" */
type TokenDatas = {
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    default_properties: Scalars["jsonb"]["output"];
    description: Scalars["String"]["output"];
    description_mutable: Scalars["Boolean"]["output"];
    largest_property_version: Scalars["numeric"]["output"];
    maximum: Scalars["numeric"]["output"];
    maximum_mutable: Scalars["Boolean"]["output"];
    metadata_uri: Scalars["String"]["output"];
    name: Scalars["String"]["output"];
    payee_address: Scalars["String"]["output"];
    properties_mutable: Scalars["Boolean"]["output"];
    royalty_mutable: Scalars["Boolean"]["output"];
    royalty_points_denominator: Scalars["numeric"]["output"];
    royalty_points_numerator: Scalars["numeric"]["output"];
    supply: Scalars["numeric"]["output"];
    token_data_id_hash: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
    uri_mutable: Scalars["Boolean"]["output"];
};
/** columns and relationships of "token_datas" */
type TokenDatasDefaultPropertiesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "token_datas". All fields are combined with a logical 'AND'. */
type TokenDatasBoolExp = {
    _and?: InputMaybe<Array<TokenDatasBoolExp>>;
    _not?: InputMaybe<TokenDatasBoolExp>;
    _or?: InputMaybe<Array<TokenDatasBoolExp>>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    default_properties?: InputMaybe<JsonbComparisonExp>;
    description?: InputMaybe<StringComparisonExp>;
    description_mutable?: InputMaybe<BooleanComparisonExp>;
    largest_property_version?: InputMaybe<NumericComparisonExp>;
    maximum?: InputMaybe<NumericComparisonExp>;
    maximum_mutable?: InputMaybe<BooleanComparisonExp>;
    metadata_uri?: InputMaybe<StringComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    payee_address?: InputMaybe<StringComparisonExp>;
    properties_mutable?: InputMaybe<BooleanComparisonExp>;
    royalty_mutable?: InputMaybe<BooleanComparisonExp>;
    royalty_points_denominator?: InputMaybe<NumericComparisonExp>;
    royalty_points_numerator?: InputMaybe<NumericComparisonExp>;
    supply?: InputMaybe<NumericComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
    uri_mutable?: InputMaybe<BooleanComparisonExp>;
};
/** Ordering options when selecting data from "token_datas". */
type TokenDatasOrderBy = {
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    default_properties?: InputMaybe<OrderBy>;
    description?: InputMaybe<OrderBy>;
    description_mutable?: InputMaybe<OrderBy>;
    largest_property_version?: InputMaybe<OrderBy>;
    maximum?: InputMaybe<OrderBy>;
    maximum_mutable?: InputMaybe<OrderBy>;
    metadata_uri?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    payee_address?: InputMaybe<OrderBy>;
    properties_mutable?: InputMaybe<OrderBy>;
    royalty_mutable?: InputMaybe<OrderBy>;
    royalty_points_denominator?: InputMaybe<OrderBy>;
    royalty_points_numerator?: InputMaybe<OrderBy>;
    supply?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
    uri_mutable?: InputMaybe<OrderBy>;
};
/** select columns of table "token_datas" */
declare enum TokenDatasSelectColumn {
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    DefaultProperties = "default_properties",
    /** column name */
    Description = "description",
    /** column name */
    DescriptionMutable = "description_mutable",
    /** column name */
    LargestPropertyVersion = "largest_property_version",
    /** column name */
    Maximum = "maximum",
    /** column name */
    MaximumMutable = "maximum_mutable",
    /** column name */
    MetadataUri = "metadata_uri",
    /** column name */
    Name = "name",
    /** column name */
    PayeeAddress = "payee_address",
    /** column name */
    PropertiesMutable = "properties_mutable",
    /** column name */
    RoyaltyMutable = "royalty_mutable",
    /** column name */
    RoyaltyPointsDenominator = "royalty_points_denominator",
    /** column name */
    RoyaltyPointsNumerator = "royalty_points_numerator",
    /** column name */
    Supply = "supply",
    /** column name */
    TokenDataIdHash = "token_data_id_hash",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version",
    /** column name */
    UriMutable = "uri_mutable"
}
/** Streaming cursor of the table "token_datas" */
type TokenDatasStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TokenDatasStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TokenDatasStreamCursorValueInput = {
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    default_properties?: InputMaybe<Scalars["jsonb"]["input"]>;
    description?: InputMaybe<Scalars["String"]["input"]>;
    description_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    largest_property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    maximum?: InputMaybe<Scalars["numeric"]["input"]>;
    maximum_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    metadata_uri?: InputMaybe<Scalars["String"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    payee_address?: InputMaybe<Scalars["String"]["input"]>;
    properties_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    royalty_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
    royalty_points_denominator?: InputMaybe<Scalars["numeric"]["input"]>;
    royalty_points_numerator?: InputMaybe<Scalars["numeric"]["input"]>;
    supply?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
    uri_mutable?: InputMaybe<Scalars["Boolean"]["input"]>;
};
/** columns and relationships of "token_ownerships" */
type TokenOwnerships = {
    amount: Scalars["numeric"]["output"];
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    name: Scalars["String"]["output"];
    owner_address?: Maybe<Scalars["String"]["output"]>;
    property_version: Scalars["numeric"]["output"];
    table_handle: Scalars["String"]["output"];
    table_type?: Maybe<Scalars["String"]["output"]>;
    token_data_id_hash: Scalars["String"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "token_ownerships". All fields are combined with a logical 'AND'. */
type TokenOwnershipsBoolExp = {
    _and?: InputMaybe<Array<TokenOwnershipsBoolExp>>;
    _not?: InputMaybe<TokenOwnershipsBoolExp>;
    _or?: InputMaybe<Array<TokenOwnershipsBoolExp>>;
    amount?: InputMaybe<NumericComparisonExp>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    owner_address?: InputMaybe<StringComparisonExp>;
    property_version?: InputMaybe<NumericComparisonExp>;
    table_handle?: InputMaybe<StringComparisonExp>;
    table_type?: InputMaybe<StringComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "token_ownerships". */
type TokenOwnershipsOrderBy = {
    amount?: InputMaybe<OrderBy>;
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    owner_address?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    table_handle?: InputMaybe<OrderBy>;
    table_type?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "token_ownerships" */
declare enum TokenOwnershipsSelectColumn {
    /** column name */
    Amount = "amount",
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    Name = "name",
    /** column name */
    OwnerAddress = "owner_address",
    /** column name */
    PropertyVersion = "property_version",
    /** column name */
    TableHandle = "table_handle",
    /** column name */
    TableType = "table_type",
    /** column name */
    TokenDataIdHash = "token_data_id_hash",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** Streaming cursor of the table "token_ownerships" */
type TokenOwnershipsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TokenOwnershipsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TokenOwnershipsStreamCursorValueInput = {
    amount?: InputMaybe<Scalars["numeric"]["input"]>;
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    owner_address?: InputMaybe<Scalars["String"]["input"]>;
    property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    table_handle?: InputMaybe<Scalars["String"]["input"]>;
    table_type?: InputMaybe<Scalars["String"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "tokens" */
type Tokens = {
    collection_data_id_hash: Scalars["String"]["output"];
    collection_name: Scalars["String"]["output"];
    creator_address: Scalars["String"]["output"];
    name: Scalars["String"]["output"];
    property_version: Scalars["numeric"]["output"];
    token_data_id_hash: Scalars["String"]["output"];
    token_properties: Scalars["jsonb"]["output"];
    transaction_timestamp: Scalars["timestamp"]["output"];
    transaction_version: Scalars["bigint"]["output"];
};
/** columns and relationships of "tokens" */
type TokensTokenPropertiesArgs = {
    path?: InputMaybe<Scalars["String"]["input"]>;
};
/** Boolean expression to filter rows from the table "tokens". All fields are combined with a logical 'AND'. */
type TokensBoolExp = {
    _and?: InputMaybe<Array<TokensBoolExp>>;
    _not?: InputMaybe<TokensBoolExp>;
    _or?: InputMaybe<Array<TokensBoolExp>>;
    collection_data_id_hash?: InputMaybe<StringComparisonExp>;
    collection_name?: InputMaybe<StringComparisonExp>;
    creator_address?: InputMaybe<StringComparisonExp>;
    name?: InputMaybe<StringComparisonExp>;
    property_version?: InputMaybe<NumericComparisonExp>;
    token_data_id_hash?: InputMaybe<StringComparisonExp>;
    token_properties?: InputMaybe<JsonbComparisonExp>;
    transaction_timestamp?: InputMaybe<TimestampComparisonExp>;
    transaction_version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "tokens". */
type TokensOrderBy = {
    collection_data_id_hash?: InputMaybe<OrderBy>;
    collection_name?: InputMaybe<OrderBy>;
    creator_address?: InputMaybe<OrderBy>;
    name?: InputMaybe<OrderBy>;
    property_version?: InputMaybe<OrderBy>;
    token_data_id_hash?: InputMaybe<OrderBy>;
    token_properties?: InputMaybe<OrderBy>;
    transaction_timestamp?: InputMaybe<OrderBy>;
    transaction_version?: InputMaybe<OrderBy>;
};
/** select columns of table "tokens" */
declare enum TokensSelectColumn {
    /** column name */
    CollectionDataIdHash = "collection_data_id_hash",
    /** column name */
    CollectionName = "collection_name",
    /** column name */
    CreatorAddress = "creator_address",
    /** column name */
    Name = "name",
    /** column name */
    PropertyVersion = "property_version",
    /** column name */
    TokenDataIdHash = "token_data_id_hash",
    /** column name */
    TokenProperties = "token_properties",
    /** column name */
    TransactionTimestamp = "transaction_timestamp",
    /** column name */
    TransactionVersion = "transaction_version"
}
/** Streaming cursor of the table "tokens" */
type TokensStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: TokensStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type TokensStreamCursorValueInput = {
    collection_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    collection_name?: InputMaybe<Scalars["String"]["input"]>;
    creator_address?: InputMaybe<Scalars["String"]["input"]>;
    name?: InputMaybe<Scalars["String"]["input"]>;
    property_version?: InputMaybe<Scalars["numeric"]["input"]>;
    token_data_id_hash?: InputMaybe<Scalars["String"]["input"]>;
    token_properties?: InputMaybe<Scalars["jsonb"]["input"]>;
    transaction_timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    transaction_version?: InputMaybe<Scalars["bigint"]["input"]>;
};
/** columns and relationships of "user_transactions" */
type UserTransactions = {
    block_height: Scalars["bigint"]["output"];
    entry_function_id_str: Scalars["String"]["output"];
    epoch: Scalars["bigint"]["output"];
    expiration_timestamp_secs: Scalars["timestamp"]["output"];
    gas_unit_price: Scalars["numeric"]["output"];
    max_gas_amount: Scalars["numeric"]["output"];
    parent_signature_type: Scalars["String"]["output"];
    sender: Scalars["String"]["output"];
    sequence_number: Scalars["bigint"]["output"];
    timestamp: Scalars["timestamp"]["output"];
    version: Scalars["bigint"]["output"];
};
/** Boolean expression to filter rows from the table "user_transactions". All fields are combined with a logical 'AND'. */
type UserTransactionsBoolExp = {
    _and?: InputMaybe<Array<UserTransactionsBoolExp>>;
    _not?: InputMaybe<UserTransactionsBoolExp>;
    _or?: InputMaybe<Array<UserTransactionsBoolExp>>;
    block_height?: InputMaybe<BigintComparisonExp>;
    entry_function_id_str?: InputMaybe<StringComparisonExp>;
    epoch?: InputMaybe<BigintComparisonExp>;
    expiration_timestamp_secs?: InputMaybe<TimestampComparisonExp>;
    gas_unit_price?: InputMaybe<NumericComparisonExp>;
    max_gas_amount?: InputMaybe<NumericComparisonExp>;
    parent_signature_type?: InputMaybe<StringComparisonExp>;
    sender?: InputMaybe<StringComparisonExp>;
    sequence_number?: InputMaybe<BigintComparisonExp>;
    timestamp?: InputMaybe<TimestampComparisonExp>;
    version?: InputMaybe<BigintComparisonExp>;
};
/** Ordering options when selecting data from "user_transactions". */
type UserTransactionsOrderBy = {
    block_height?: InputMaybe<OrderBy>;
    entry_function_id_str?: InputMaybe<OrderBy>;
    epoch?: InputMaybe<OrderBy>;
    expiration_timestamp_secs?: InputMaybe<OrderBy>;
    gas_unit_price?: InputMaybe<OrderBy>;
    max_gas_amount?: InputMaybe<OrderBy>;
    parent_signature_type?: InputMaybe<OrderBy>;
    sender?: InputMaybe<OrderBy>;
    sequence_number?: InputMaybe<OrderBy>;
    timestamp?: InputMaybe<OrderBy>;
    version?: InputMaybe<OrderBy>;
};
/** select columns of table "user_transactions" */
declare enum UserTransactionsSelectColumn {
    /** column name */
    BlockHeight = "block_height",
    /** column name */
    EntryFunctionIdStr = "entry_function_id_str",
    /** column name */
    Epoch = "epoch",
    /** column name */
    ExpirationTimestampSecs = "expiration_timestamp_secs",
    /** column name */
    GasUnitPrice = "gas_unit_price",
    /** column name */
    MaxGasAmount = "max_gas_amount",
    /** column name */
    ParentSignatureType = "parent_signature_type",
    /** column name */
    Sender = "sender",
    /** column name */
    SequenceNumber = "sequence_number",
    /** column name */
    Timestamp = "timestamp",
    /** column name */
    Version = "version"
}
/** Streaming cursor of the table "user_transactions" */
type UserTransactionsStreamCursorInput = {
    /** Stream column input with initial value */
    initial_value: UserTransactionsStreamCursorValueInput;
    /** cursor ordering */
    ordering?: InputMaybe<CursorOrdering>;
};
/** Initial value of the column from where the streaming should start */
type UserTransactionsStreamCursorValueInput = {
    block_height?: InputMaybe<Scalars["bigint"]["input"]>;
    entry_function_id_str?: InputMaybe<Scalars["String"]["input"]>;
    epoch?: InputMaybe<Scalars["bigint"]["input"]>;
    expiration_timestamp_secs?: InputMaybe<Scalars["timestamp"]["input"]>;
    gas_unit_price?: InputMaybe<Scalars["numeric"]["input"]>;
    max_gas_amount?: InputMaybe<Scalars["numeric"]["input"]>;
    parent_signature_type?: InputMaybe<Scalars["String"]["input"]>;
    sender?: InputMaybe<Scalars["String"]["input"]>;
    sequence_number?: InputMaybe<Scalars["bigint"]["input"]>;
    timestamp?: InputMaybe<Scalars["timestamp"]["input"]>;
    version?: InputMaybe<Scalars["bigint"]["input"]>;
};

export { type AccountTransactions, type AccountTransactionsAggregate, type AccountTransactionsAggregateFields, type AccountTransactionsAggregateFieldsCountArgs, type AccountTransactionsAvgFields, type AccountTransactionsBoolExp, type AccountTransactionsCoinActivitiesAggregateArgs, type AccountTransactionsCoinActivitiesArgs, type AccountTransactionsDelegatedStakingActivitiesArgs, type AccountTransactionsFungibleAssetActivitiesArgs, type AccountTransactionsMaxFields, type AccountTransactionsMinFields, type AccountTransactionsOrderBy, AccountTransactionsSelectColumn, type AccountTransactionsStddevFields, type AccountTransactionsStddevPopFields, type AccountTransactionsStddevSampFields, type AccountTransactionsStreamCursorInput, type AccountTransactionsStreamCursorValueInput, type AccountTransactionsSumFields, type AccountTransactionsTokenActivitiesAggregateArgs, type AccountTransactionsTokenActivitiesArgs, type AccountTransactionsTokenActivitiesV2AggregateArgs, type AccountTransactionsTokenActivitiesV2Args, type AccountTransactionsVarPopFields, type AccountTransactionsVarSampFields, type AccountTransactionsVarianceFields, type AddressEventsSummary, type AddressEventsSummaryBoolExp, type AddressEventsSummaryOrderBy, AddressEventsSummarySelectColumn, type AddressEventsSummaryStreamCursorInput, type AddressEventsSummaryStreamCursorValueInput, type AddressVersionFromEvents, type AddressVersionFromEventsAggregate, type AddressVersionFromEventsAggregateFields, type AddressVersionFromEventsAggregateFieldsCountArgs, type AddressVersionFromEventsAvgFields, type AddressVersionFromEventsBoolExp, type AddressVersionFromEventsCoinActivitiesAggregateArgs, type AddressVersionFromEventsCoinActivitiesArgs, type AddressVersionFromEventsDelegatedStakingActivitiesArgs, type AddressVersionFromEventsMaxFields, type AddressVersionFromEventsMinFields, type AddressVersionFromEventsOrderBy, AddressVersionFromEventsSelectColumn, type AddressVersionFromEventsStddevFields, type AddressVersionFromEventsStddevPopFields, type AddressVersionFromEventsStddevSampFields, type AddressVersionFromEventsStreamCursorInput, type AddressVersionFromEventsStreamCursorValueInput, type AddressVersionFromEventsSumFields, type AddressVersionFromEventsTokenActivitiesAggregateArgs, type AddressVersionFromEventsTokenActivitiesArgs, type AddressVersionFromEventsTokenActivitiesV2AggregateArgs, type AddressVersionFromEventsTokenActivitiesV2Args, type AddressVersionFromEventsVarPopFields, type AddressVersionFromEventsVarSampFields, type AddressVersionFromEventsVarianceFields, type AddressVersionFromMoveResources, type AddressVersionFromMoveResourcesAggregate, type AddressVersionFromMoveResourcesAggregateFields, type AddressVersionFromMoveResourcesAggregateFieldsCountArgs, type AddressVersionFromMoveResourcesAvgFields, type AddressVersionFromMoveResourcesBoolExp, type AddressVersionFromMoveResourcesCoinActivitiesAggregateArgs, type AddressVersionFromMoveResourcesCoinActivitiesArgs, type AddressVersionFromMoveResourcesDelegatedStakingActivitiesArgs, type AddressVersionFromMoveResourcesMaxFields, type AddressVersionFromMoveResourcesMinFields, type AddressVersionFromMoveResourcesOrderBy, AddressVersionFromMoveResourcesSelectColumn, type AddressVersionFromMoveResourcesStddevFields, type AddressVersionFromMoveResourcesStddevPopFields, type AddressVersionFromMoveResourcesStddevSampFields, type AddressVersionFromMoveResourcesStreamCursorInput, type AddressVersionFromMoveResourcesStreamCursorValueInput, type AddressVersionFromMoveResourcesSumFields, type AddressVersionFromMoveResourcesTokenActivitiesAggregateArgs, type AddressVersionFromMoveResourcesTokenActivitiesArgs, type AddressVersionFromMoveResourcesTokenActivitiesV2AggregateArgs, type AddressVersionFromMoveResourcesTokenActivitiesV2Args, type AddressVersionFromMoveResourcesVarPopFields, type AddressVersionFromMoveResourcesVarSampFields, type AddressVersionFromMoveResourcesVarianceFields, type BigintComparisonExp, type BlockMetadataTransactions, type BlockMetadataTransactionsBoolExp, type BlockMetadataTransactionsFailedProposerIndicesArgs, type BlockMetadataTransactionsOrderBy, type BlockMetadataTransactionsPreviousBlockVotesBitvecArgs, BlockMetadataTransactionsSelectColumn, type BlockMetadataTransactionsStreamCursorInput, type BlockMetadataTransactionsStreamCursorValueInput, type BooleanComparisonExp, type CoinActivities, type CoinActivitiesAggregate, type CoinActivitiesAggregateBoolExp, type CoinActivitiesAggregateBoolExpBoolAnd, type CoinActivitiesAggregateBoolExpBoolOr, type CoinActivitiesAggregateBoolExpCount, type CoinActivitiesAggregateFields, type CoinActivitiesAggregateFieldsCountArgs, type CoinActivitiesAggregateOrderBy, type CoinActivitiesAptosNamesAggregateArgs, type CoinActivitiesAptosNamesArgs, type CoinActivitiesAvgFields, type CoinActivitiesAvgOrderBy, type CoinActivitiesBoolExp, type CoinActivitiesMaxFields, type CoinActivitiesMaxOrderBy, type CoinActivitiesMinFields, type CoinActivitiesMinOrderBy, type CoinActivitiesOrderBy, CoinActivitiesSelectColumn, CoinActivitiesSelectColumnCoinActivitiesAggregateBoolExpBoolAndArgumentsColumns, CoinActivitiesSelectColumnCoinActivitiesAggregateBoolExpBoolOrArgumentsColumns, type CoinActivitiesStddevFields, type CoinActivitiesStddevOrderBy, type CoinActivitiesStddevPopFields, type CoinActivitiesStddevPopOrderBy, type CoinActivitiesStddevSampFields, type CoinActivitiesStddevSampOrderBy, type CoinActivitiesStreamCursorInput, type CoinActivitiesStreamCursorValueInput, type CoinActivitiesSumFields, type CoinActivitiesSumOrderBy, type CoinActivitiesVarPopFields, type CoinActivitiesVarPopOrderBy, type CoinActivitiesVarSampFields, type CoinActivitiesVarSampOrderBy, type CoinActivitiesVarianceFields, type CoinActivitiesVarianceOrderBy, type CoinBalances, type CoinBalancesBoolExp, type CoinBalancesOrderBy, CoinBalancesSelectColumn, type CoinBalancesStreamCursorInput, type CoinBalancesStreamCursorValueInput, type CoinInfos, type CoinInfosBoolExp, type CoinInfosOrderBy, CoinInfosSelectColumn, type CoinInfosStreamCursorInput, type CoinInfosStreamCursorValueInput, type CoinSupply, type CoinSupplyBoolExp, type CoinSupplyOrderBy, CoinSupplySelectColumn, type CoinSupplyStreamCursorInput, type CoinSupplyStreamCursorValueInput, type CollectionDatas, type CollectionDatasBoolExp, type CollectionDatasOrderBy, CollectionDatasSelectColumn, type CollectionDatasStreamCursorInput, type CollectionDatasStreamCursorValueInput, type CurrentAnsLookup, type CurrentAnsLookupAllTokenOwnershipsAggregateArgs, type CurrentAnsLookupAllTokenOwnershipsArgs, type CurrentAnsLookupBoolExp, type CurrentAnsLookupOrderBy, CurrentAnsLookupSelectColumn, type CurrentAnsLookupStreamCursorInput, type CurrentAnsLookupStreamCursorValueInput, type CurrentAnsLookupV2, type CurrentAnsLookupV2BoolExp, type CurrentAnsLookupV2OrderBy, CurrentAnsLookupV2SelectColumn, type CurrentAnsLookupV2StreamCursorInput, type CurrentAnsLookupV2StreamCursorValueInput, type CurrentAptosNames, type CurrentAptosNamesAggregate, type CurrentAptosNamesAggregateBoolExp, type CurrentAptosNamesAggregateBoolExpBoolAnd, type CurrentAptosNamesAggregateBoolExpBoolOr, type CurrentAptosNamesAggregateBoolExpCount, type CurrentAptosNamesAggregateFields, type CurrentAptosNamesAggregateFieldsCountArgs, type CurrentAptosNamesAggregateOrderBy, type CurrentAptosNamesAvgFields, type CurrentAptosNamesAvgOrderBy, type CurrentAptosNamesBoolExp, type CurrentAptosNamesMaxFields, type CurrentAptosNamesMaxOrderBy, type CurrentAptosNamesMinFields, type CurrentAptosNamesMinOrderBy, type CurrentAptosNamesOrderBy, CurrentAptosNamesSelectColumn, CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolAndArgumentsColumns, CurrentAptosNamesSelectColumnCurrentAptosNamesAggregateBoolExpBoolOrArgumentsColumns, type CurrentAptosNamesStddevFields, type CurrentAptosNamesStddevOrderBy, type CurrentAptosNamesStddevPopFields, type CurrentAptosNamesStddevPopOrderBy, type CurrentAptosNamesStddevSampFields, type CurrentAptosNamesStddevSampOrderBy, type CurrentAptosNamesStreamCursorInput, type CurrentAptosNamesStreamCursorValueInput, type CurrentAptosNamesSumFields, type CurrentAptosNamesSumOrderBy, type CurrentAptosNamesVarPopFields, type CurrentAptosNamesVarPopOrderBy, type CurrentAptosNamesVarSampFields, type CurrentAptosNamesVarSampOrderBy, type CurrentAptosNamesVarianceFields, type CurrentAptosNamesVarianceOrderBy, type CurrentCoinBalances, type CurrentCoinBalancesBoolExp, type CurrentCoinBalancesOrderBy, CurrentCoinBalancesSelectColumn, type CurrentCoinBalancesStreamCursorInput, type CurrentCoinBalancesStreamCursorValueInput, type CurrentCollectionDatas, type CurrentCollectionDatasBoolExp, type CurrentCollectionDatasOrderBy, CurrentCollectionDatasSelectColumn, type CurrentCollectionDatasStreamCursorInput, type CurrentCollectionDatasStreamCursorValueInput, type CurrentCollectionOwnershipV2View, type CurrentCollectionOwnershipV2ViewAggregate, type CurrentCollectionOwnershipV2ViewAggregateFields, type CurrentCollectionOwnershipV2ViewAggregateFieldsCountArgs, type CurrentCollectionOwnershipV2ViewAvgFields, type CurrentCollectionOwnershipV2ViewBoolExp, type CurrentCollectionOwnershipV2ViewMaxFields, type CurrentCollectionOwnershipV2ViewMinFields, type CurrentCollectionOwnershipV2ViewOrderBy, CurrentCollectionOwnershipV2ViewSelectColumn, type CurrentCollectionOwnershipV2ViewStddevFields, type CurrentCollectionOwnershipV2ViewStddevPopFields, type CurrentCollectionOwnershipV2ViewStddevSampFields, type CurrentCollectionOwnershipV2ViewStreamCursorInput, type CurrentCollectionOwnershipV2ViewStreamCursorValueInput, type CurrentCollectionOwnershipV2ViewSumFields, type CurrentCollectionOwnershipV2ViewVarPopFields, type CurrentCollectionOwnershipV2ViewVarSampFields, type CurrentCollectionOwnershipV2ViewVarianceFields, type CurrentCollectionsV2, type CurrentCollectionsV2BoolExp, type CurrentCollectionsV2OrderBy, CurrentCollectionsV2SelectColumn, type CurrentCollectionsV2StreamCursorInput, type CurrentCollectionsV2StreamCursorValueInput, type CurrentDelegatedStakingPoolBalances, type CurrentDelegatedStakingPoolBalancesBoolExp, type CurrentDelegatedStakingPoolBalancesOrderBy, CurrentDelegatedStakingPoolBalancesSelectColumn, type CurrentDelegatedStakingPoolBalancesStreamCursorInput, type CurrentDelegatedStakingPoolBalancesStreamCursorValueInput, type CurrentDelegatedVoter, type CurrentDelegatedVoterBoolExp, type CurrentDelegatedVoterOrderBy, CurrentDelegatedVoterSelectColumn, type CurrentDelegatedVoterStreamCursorInput, type CurrentDelegatedVoterStreamCursorValueInput, type CurrentDelegatorBalances, type CurrentDelegatorBalancesBoolExp, type CurrentDelegatorBalancesOrderBy, CurrentDelegatorBalancesSelectColumn, type CurrentDelegatorBalancesStreamCursorInput, type CurrentDelegatorBalancesStreamCursorValueInput, type CurrentFungibleAssetBalances, type CurrentFungibleAssetBalancesAggregate, type CurrentFungibleAssetBalancesAggregateFields, type CurrentFungibleAssetBalancesAggregateFieldsCountArgs, type CurrentFungibleAssetBalancesAvgFields, type CurrentFungibleAssetBalancesBoolExp, type CurrentFungibleAssetBalancesMaxFields, type CurrentFungibleAssetBalancesMinFields, type CurrentFungibleAssetBalancesOrderBy, CurrentFungibleAssetBalancesSelectColumn, type CurrentFungibleAssetBalancesStddevFields, type CurrentFungibleAssetBalancesStddevPopFields, type CurrentFungibleAssetBalancesStddevSampFields, type CurrentFungibleAssetBalancesStreamCursorInput, type CurrentFungibleAssetBalancesStreamCursorValueInput, type CurrentFungibleAssetBalancesSumFields, type CurrentFungibleAssetBalancesVarPopFields, type CurrentFungibleAssetBalancesVarSampFields, type CurrentFungibleAssetBalancesVarianceFields, type CurrentObjects, type CurrentObjectsBoolExp, type CurrentObjectsOrderBy, CurrentObjectsSelectColumn, type CurrentObjectsStreamCursorInput, type CurrentObjectsStreamCursorValueInput, type CurrentStakingPoolVoter, type CurrentStakingPoolVoterBoolExp, type CurrentStakingPoolVoterOperatorAptosNameAggregateArgs, type CurrentStakingPoolVoterOperatorAptosNameArgs, type CurrentStakingPoolVoterOrderBy, CurrentStakingPoolVoterSelectColumn, type CurrentStakingPoolVoterStreamCursorInput, type CurrentStakingPoolVoterStreamCursorValueInput, type CurrentTableItems, type CurrentTableItemsBoolExp, type CurrentTableItemsDecodedKeyArgs, type CurrentTableItemsDecodedValueArgs, type CurrentTableItemsOrderBy, CurrentTableItemsSelectColumn, type CurrentTableItemsStreamCursorInput, type CurrentTableItemsStreamCursorValueInput, type CurrentTokenDatas, type CurrentTokenDatasBoolExp, type CurrentTokenDatasDefaultPropertiesArgs, type CurrentTokenDatasOrderBy, CurrentTokenDatasSelectColumn, type CurrentTokenDatasStreamCursorInput, type CurrentTokenDatasStreamCursorValueInput, type CurrentTokenDatasV2, type CurrentTokenDatasV2BoolExp, type CurrentTokenDatasV2CurrentTokenOwnershipsAggregateArgs, type CurrentTokenDatasV2CurrentTokenOwnershipsArgs, type CurrentTokenDatasV2OrderBy, CurrentTokenDatasV2SelectColumn, type CurrentTokenDatasV2StreamCursorInput, type CurrentTokenDatasV2StreamCursorValueInput, type CurrentTokenDatasV2TokenPropertiesArgs, type CurrentTokenOwnerships, type CurrentTokenOwnershipsAggregate, type CurrentTokenOwnershipsAggregateBoolExp, type CurrentTokenOwnershipsAggregateBoolExpCount, type CurrentTokenOwnershipsAggregateFields, type CurrentTokenOwnershipsAggregateFieldsCountArgs, type CurrentTokenOwnershipsAggregateOrderBy, type CurrentTokenOwnershipsAvgFields, type CurrentTokenOwnershipsAvgOrderBy, type CurrentTokenOwnershipsBoolExp, type CurrentTokenOwnershipsMaxFields, type CurrentTokenOwnershipsMaxOrderBy, type CurrentTokenOwnershipsMinFields, type CurrentTokenOwnershipsMinOrderBy, type CurrentTokenOwnershipsOrderBy, CurrentTokenOwnershipsSelectColumn, type CurrentTokenOwnershipsStddevFields, type CurrentTokenOwnershipsStddevOrderBy, type CurrentTokenOwnershipsStddevPopFields, type CurrentTokenOwnershipsStddevPopOrderBy, type CurrentTokenOwnershipsStddevSampFields, type CurrentTokenOwnershipsStddevSampOrderBy, type CurrentTokenOwnershipsStreamCursorInput, type CurrentTokenOwnershipsStreamCursorValueInput, type CurrentTokenOwnershipsSumFields, type CurrentTokenOwnershipsSumOrderBy, type CurrentTokenOwnershipsTokenPropertiesArgs, type CurrentTokenOwnershipsV2, type CurrentTokenOwnershipsV2Aggregate, type CurrentTokenOwnershipsV2AggregateBoolExp, type CurrentTokenOwnershipsV2AggregateBoolExpBoolAnd, type CurrentTokenOwnershipsV2AggregateBoolExpBoolOr, type CurrentTokenOwnershipsV2AggregateBoolExpCount, type CurrentTokenOwnershipsV2AggregateFields, type CurrentTokenOwnershipsV2AggregateFieldsCountArgs, type CurrentTokenOwnershipsV2AggregateOrderBy, type CurrentTokenOwnershipsV2AvgFields, type CurrentTokenOwnershipsV2AvgOrderBy, type CurrentTokenOwnershipsV2BoolExp, type CurrentTokenOwnershipsV2ComposedNftsAggregateArgs, type CurrentTokenOwnershipsV2ComposedNftsArgs, type CurrentTokenOwnershipsV2MaxFields, type CurrentTokenOwnershipsV2MaxOrderBy, type CurrentTokenOwnershipsV2MinFields, type CurrentTokenOwnershipsV2MinOrderBy, type CurrentTokenOwnershipsV2OrderBy, CurrentTokenOwnershipsV2SelectColumn, CurrentTokenOwnershipsV2SelectColumnCurrentTokenOwnershipsV2AggregateBoolExpBoolAndArgumentsColumns, CurrentTokenOwnershipsV2SelectColumnCurrentTokenOwnershipsV2AggregateBoolExpBoolOrArgumentsColumns, type CurrentTokenOwnershipsV2StddevFields, type CurrentTokenOwnershipsV2StddevOrderBy, type CurrentTokenOwnershipsV2StddevPopFields, type CurrentTokenOwnershipsV2StddevPopOrderBy, type CurrentTokenOwnershipsV2StddevSampFields, type CurrentTokenOwnershipsV2StddevSampOrderBy, type CurrentTokenOwnershipsV2StreamCursorInput, type CurrentTokenOwnershipsV2StreamCursorValueInput, type CurrentTokenOwnershipsV2SumFields, type CurrentTokenOwnershipsV2SumOrderBy, type CurrentTokenOwnershipsV2TokenPropertiesMutatedV1Args, type CurrentTokenOwnershipsV2VarPopFields, type CurrentTokenOwnershipsV2VarPopOrderBy, type CurrentTokenOwnershipsV2VarSampFields, type CurrentTokenOwnershipsV2VarSampOrderBy, type CurrentTokenOwnershipsV2VarianceFields, type CurrentTokenOwnershipsV2VarianceOrderBy, type CurrentTokenOwnershipsVarPopFields, type CurrentTokenOwnershipsVarPopOrderBy, type CurrentTokenOwnershipsVarSampFields, type CurrentTokenOwnershipsVarSampOrderBy, type CurrentTokenOwnershipsVarianceFields, type CurrentTokenOwnershipsVarianceOrderBy, type CurrentTokenPendingClaims, type CurrentTokenPendingClaimsBoolExp, type CurrentTokenPendingClaimsOrderBy, CurrentTokenPendingClaimsSelectColumn, type CurrentTokenPendingClaimsStreamCursorInput, type CurrentTokenPendingClaimsStreamCursorValueInput, CursorOrdering, type DelegatedStakingActivities, type DelegatedStakingActivitiesAggregateOrderBy, type DelegatedStakingActivitiesAvgOrderBy, type DelegatedStakingActivitiesBoolExp, type DelegatedStakingActivitiesMaxOrderBy, type DelegatedStakingActivitiesMinOrderBy, type DelegatedStakingActivitiesOrderBy, DelegatedStakingActivitiesSelectColumn, type DelegatedStakingActivitiesStddevOrderBy, type DelegatedStakingActivitiesStddevPopOrderBy, type DelegatedStakingActivitiesStddevSampOrderBy, type DelegatedStakingActivitiesStreamCursorInput, type DelegatedStakingActivitiesStreamCursorValueInput, type DelegatedStakingActivitiesSumOrderBy, type DelegatedStakingActivitiesVarPopOrderBy, type DelegatedStakingActivitiesVarSampOrderBy, type DelegatedStakingActivitiesVarianceOrderBy, type DelegatedStakingPoolBalances, type DelegatedStakingPoolBalancesAggregate, type DelegatedStakingPoolBalancesAggregateFields, type DelegatedStakingPoolBalancesAggregateFieldsCountArgs, type DelegatedStakingPoolBalancesAvgFields, type DelegatedStakingPoolBalancesBoolExp, type DelegatedStakingPoolBalancesMaxFields, type DelegatedStakingPoolBalancesMinFields, type DelegatedStakingPoolBalancesOrderBy, DelegatedStakingPoolBalancesSelectColumn, type DelegatedStakingPoolBalancesStddevFields, type DelegatedStakingPoolBalancesStddevPopFields, type DelegatedStakingPoolBalancesStddevSampFields, type DelegatedStakingPoolBalancesStreamCursorInput, type DelegatedStakingPoolBalancesStreamCursorValueInput, type DelegatedStakingPoolBalancesSumFields, type DelegatedStakingPoolBalancesVarPopFields, type DelegatedStakingPoolBalancesVarSampFields, type DelegatedStakingPoolBalancesVarianceFields, type DelegatedStakingPools, type DelegatedStakingPoolsBoolExp, type DelegatedStakingPoolsOrderBy, DelegatedStakingPoolsSelectColumn, type DelegatedStakingPoolsStreamCursorInput, type DelegatedStakingPoolsStreamCursorValueInput, type DelegatorDistinctPool, type DelegatorDistinctPoolAggregate, type DelegatorDistinctPoolAggregateFields, type DelegatorDistinctPoolAggregateFieldsCountArgs, type DelegatorDistinctPoolBoolExp, type DelegatorDistinctPoolMaxFields, type DelegatorDistinctPoolMinFields, type DelegatorDistinctPoolOrderBy, DelegatorDistinctPoolSelectColumn, type DelegatorDistinctPoolStreamCursorInput, type DelegatorDistinctPoolStreamCursorValueInput, type Events, type EventsBoolExp, type EventsDataArgs, type EventsOrderBy, EventsSelectColumn, type EventsStreamCursorInput, type EventsStreamCursorValueInput, type Exact, type FungibleAssetActivities, type FungibleAssetActivitiesAggregateOrderBy, type FungibleAssetActivitiesAvgOrderBy, type FungibleAssetActivitiesBoolExp, type FungibleAssetActivitiesMaxOrderBy, type FungibleAssetActivitiesMinOrderBy, type FungibleAssetActivitiesOrderBy, type FungibleAssetActivitiesOwnerAptosNamesAggregateArgs, type FungibleAssetActivitiesOwnerAptosNamesArgs, FungibleAssetActivitiesSelectColumn, type FungibleAssetActivitiesStddevOrderBy, type FungibleAssetActivitiesStddevPopOrderBy, type FungibleAssetActivitiesStddevSampOrderBy, type FungibleAssetActivitiesStreamCursorInput, type FungibleAssetActivitiesStreamCursorValueInput, type FungibleAssetActivitiesSumOrderBy, type FungibleAssetActivitiesVarPopOrderBy, type FungibleAssetActivitiesVarSampOrderBy, type FungibleAssetActivitiesVarianceOrderBy, type FungibleAssetMetadata, type FungibleAssetMetadataBoolExp, type FungibleAssetMetadataOrderBy, FungibleAssetMetadataSelectColumn, type FungibleAssetMetadataStreamCursorInput, type FungibleAssetMetadataStreamCursorValueInput, type Incremental, type IndexerStatus, type IndexerStatusBoolExp, type IndexerStatusOrderBy, IndexerStatusSelectColumn, type IndexerStatusStreamCursorInput, type IndexerStatusStreamCursorValueInput, type InputMaybe, type IntComparisonExp, type JsonbCastExp, type JsonbComparisonExp, type LedgerInfos, type LedgerInfosBoolExp, type LedgerInfosOrderBy, LedgerInfosSelectColumn, type LedgerInfosStreamCursorInput, type LedgerInfosStreamCursorValueInput, type MakeEmpty, type MakeMaybe, type MakeOptional, type Maybe, type MoveResources, type MoveResourcesAggregate, type MoveResourcesAggregateFields, type MoveResourcesAggregateFieldsCountArgs, type MoveResourcesAvgFields, type MoveResourcesBoolExp, type MoveResourcesMaxFields, type MoveResourcesMinFields, type MoveResourcesOrderBy, MoveResourcesSelectColumn, type MoveResourcesStddevFields, type MoveResourcesStddevPopFields, type MoveResourcesStddevSampFields, type MoveResourcesStreamCursorInput, type MoveResourcesStreamCursorValueInput, type MoveResourcesSumFields, type MoveResourcesVarPopFields, type MoveResourcesVarSampFields, type MoveResourcesVarianceFields, type NftMarketplaceV2CurrentNftMarketplaceAuctions, type NftMarketplaceV2CurrentNftMarketplaceAuctionsBoolExp, type NftMarketplaceV2CurrentNftMarketplaceAuctionsOrderBy, NftMarketplaceV2CurrentNftMarketplaceAuctionsSelectColumn, type NftMarketplaceV2CurrentNftMarketplaceAuctionsStreamCursorInput, type NftMarketplaceV2CurrentNftMarketplaceAuctionsStreamCursorValueInput, type NftMarketplaceV2CurrentNftMarketplaceCollectionOffers, type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersBoolExp, type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersOrderBy, NftMarketplaceV2CurrentNftMarketplaceCollectionOffersSelectColumn, type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamCursorInput, type NftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamCursorValueInput, type NftMarketplaceV2CurrentNftMarketplaceListings, type NftMarketplaceV2CurrentNftMarketplaceListingsAggregate, type NftMarketplaceV2CurrentNftMarketplaceListingsAggregateFields, type NftMarketplaceV2CurrentNftMarketplaceListingsAggregateFieldsCountArgs, type NftMarketplaceV2CurrentNftMarketplaceListingsAvgFields, type NftMarketplaceV2CurrentNftMarketplaceListingsBoolExp, type NftMarketplaceV2CurrentNftMarketplaceListingsMaxFields, type NftMarketplaceV2CurrentNftMarketplaceListingsMinFields, type NftMarketplaceV2CurrentNftMarketplaceListingsOrderBy, NftMarketplaceV2CurrentNftMarketplaceListingsSelectColumn, type NftMarketplaceV2CurrentNftMarketplaceListingsStddevFields, type NftMarketplaceV2CurrentNftMarketplaceListingsStddevPopFields, type NftMarketplaceV2CurrentNftMarketplaceListingsStddevSampFields, type NftMarketplaceV2CurrentNftMarketplaceListingsStreamCursorInput, type NftMarketplaceV2CurrentNftMarketplaceListingsStreamCursorValueInput, type NftMarketplaceV2CurrentNftMarketplaceListingsSumFields, type NftMarketplaceV2CurrentNftMarketplaceListingsVarPopFields, type NftMarketplaceV2CurrentNftMarketplaceListingsVarSampFields, type NftMarketplaceV2CurrentNftMarketplaceListingsVarianceFields, type NftMarketplaceV2CurrentNftMarketplaceTokenOffers, type NftMarketplaceV2CurrentNftMarketplaceTokenOffersBoolExp, type NftMarketplaceV2CurrentNftMarketplaceTokenOffersOrderBy, NftMarketplaceV2CurrentNftMarketplaceTokenOffersSelectColumn, type NftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamCursorInput, type NftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamCursorValueInput, type NftMarketplaceV2NftMarketplaceActivities, type NftMarketplaceV2NftMarketplaceActivitiesBoolExp, type NftMarketplaceV2NftMarketplaceActivitiesOrderBy, NftMarketplaceV2NftMarketplaceActivitiesSelectColumn, type NftMarketplaceV2NftMarketplaceActivitiesStreamCursorInput, type NftMarketplaceV2NftMarketplaceActivitiesStreamCursorValueInput, type NftMetadataCrawlerParsedAssetUris, type NftMetadataCrawlerParsedAssetUrisBoolExp, type NftMetadataCrawlerParsedAssetUrisOrderBy, NftMetadataCrawlerParsedAssetUrisSelectColumn, type NftMetadataCrawlerParsedAssetUrisStreamCursorInput, type NftMetadataCrawlerParsedAssetUrisStreamCursorValueInput, type NumActiveDelegatorPerPool, type NumActiveDelegatorPerPoolBoolExp, type NumActiveDelegatorPerPoolOrderBy, NumActiveDelegatorPerPoolSelectColumn, type NumActiveDelegatorPerPoolStreamCursorInput, type NumActiveDelegatorPerPoolStreamCursorValueInput, type NumericComparisonExp, OrderBy, type ProcessorStatus, type ProcessorStatusBoolExp, type ProcessorStatusOrderBy, ProcessorStatusSelectColumn, type ProcessorStatusStreamCursorInput, type ProcessorStatusStreamCursorValueInput, type ProposalVotes, type ProposalVotesAggregate, type ProposalVotesAggregateFields, type ProposalVotesAggregateFieldsCountArgs, type ProposalVotesAvgFields, type ProposalVotesBoolExp, type ProposalVotesMaxFields, type ProposalVotesMinFields, type ProposalVotesOrderBy, ProposalVotesSelectColumn, type ProposalVotesStddevFields, type ProposalVotesStddevPopFields, type ProposalVotesStddevSampFields, type ProposalVotesStreamCursorInput, type ProposalVotesStreamCursorValueInput, type ProposalVotesSumFields, type ProposalVotesVarPopFields, type ProposalVotesVarSampFields, type ProposalVotesVarianceFields, type QueryRoot, type QueryRootAccountTransactionsAggregateArgs, type QueryRootAccountTransactionsArgs, type QueryRootAccountTransactionsByPkArgs, type QueryRootAddressEventsSummaryArgs, type QueryRootAddressVersionFromEventsAggregateArgs, type QueryRootAddressVersionFromEventsArgs, type QueryRootAddressVersionFromMoveResourcesAggregateArgs, type QueryRootAddressVersionFromMoveResourcesArgs, type QueryRootBlockMetadataTransactionsArgs, type QueryRootBlockMetadataTransactionsByPkArgs, type QueryRootCoinActivitiesAggregateArgs, type QueryRootCoinActivitiesArgs, type QueryRootCoinActivitiesByPkArgs, type QueryRootCoinBalancesArgs, type QueryRootCoinBalancesByPkArgs, type QueryRootCoinInfosArgs, type QueryRootCoinInfosByPkArgs, type QueryRootCoinSupplyArgs, type QueryRootCoinSupplyByPkArgs, type QueryRootCollectionDatasArgs, type QueryRootCollectionDatasByPkArgs, type QueryRootCurrentAnsLookupArgs, type QueryRootCurrentAnsLookupByPkArgs, type QueryRootCurrentAnsLookupV2Args, type QueryRootCurrentAnsLookupV2ByPkArgs, type QueryRootCurrentAptosNamesAggregateArgs, type QueryRootCurrentAptosNamesArgs, type QueryRootCurrentCoinBalancesArgs, type QueryRootCurrentCoinBalancesByPkArgs, type QueryRootCurrentCollectionDatasArgs, type QueryRootCurrentCollectionDatasByPkArgs, type QueryRootCurrentCollectionOwnershipV2ViewAggregateArgs, type QueryRootCurrentCollectionOwnershipV2ViewArgs, type QueryRootCurrentCollectionsV2Args, type QueryRootCurrentCollectionsV2ByPkArgs, type QueryRootCurrentDelegatedStakingPoolBalancesArgs, type QueryRootCurrentDelegatedStakingPoolBalancesByPkArgs, type QueryRootCurrentDelegatedVoterArgs, type QueryRootCurrentDelegatedVoterByPkArgs, type QueryRootCurrentDelegatorBalancesArgs, type QueryRootCurrentDelegatorBalancesByPkArgs, type QueryRootCurrentFungibleAssetBalancesAggregateArgs, type QueryRootCurrentFungibleAssetBalancesArgs, type QueryRootCurrentFungibleAssetBalancesByPkArgs, type QueryRootCurrentObjectsArgs, type QueryRootCurrentObjectsByPkArgs, type QueryRootCurrentStakingPoolVoterArgs, type QueryRootCurrentStakingPoolVoterByPkArgs, type QueryRootCurrentTableItemsArgs, type QueryRootCurrentTableItemsByPkArgs, type QueryRootCurrentTokenDatasArgs, type QueryRootCurrentTokenDatasByPkArgs, type QueryRootCurrentTokenDatasV2Args, type QueryRootCurrentTokenDatasV2ByPkArgs, type QueryRootCurrentTokenOwnershipsAggregateArgs, type QueryRootCurrentTokenOwnershipsArgs, type QueryRootCurrentTokenOwnershipsByPkArgs, type QueryRootCurrentTokenOwnershipsV2AggregateArgs, type QueryRootCurrentTokenOwnershipsV2Args, type QueryRootCurrentTokenOwnershipsV2ByPkArgs, type QueryRootCurrentTokenPendingClaimsArgs, type QueryRootCurrentTokenPendingClaimsByPkArgs, type QueryRootDelegatedStakingActivitiesArgs, type QueryRootDelegatedStakingActivitiesByPkArgs, type QueryRootDelegatedStakingPoolBalancesAggregateArgs, type QueryRootDelegatedStakingPoolBalancesArgs, type QueryRootDelegatedStakingPoolBalancesByPkArgs, type QueryRootDelegatedStakingPoolsArgs, type QueryRootDelegatedStakingPoolsByPkArgs, type QueryRootDelegatorDistinctPoolAggregateArgs, type QueryRootDelegatorDistinctPoolArgs, type QueryRootEventsArgs, type QueryRootEventsByPkArgs, type QueryRootFungibleAssetActivitiesArgs, type QueryRootFungibleAssetActivitiesByPkArgs, type QueryRootFungibleAssetMetadataArgs, type QueryRootFungibleAssetMetadataByPkArgs, type QueryRootIndexerStatusArgs, type QueryRootIndexerStatusByPkArgs, type QueryRootLedgerInfosArgs, type QueryRootLedgerInfosByPkArgs, type QueryRootMoveResourcesAggregateArgs, type QueryRootMoveResourcesArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceAuctionsArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceAuctionsByPkArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersByPkArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceListingsAggregateArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceListingsArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceListingsByPkArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersArgs, type QueryRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersByPkArgs, type QueryRootNftMarketplaceV2NftMarketplaceActivitiesArgs, type QueryRootNftMarketplaceV2NftMarketplaceActivitiesByPkArgs, type QueryRootNftMetadataCrawlerParsedAssetUrisArgs, type QueryRootNftMetadataCrawlerParsedAssetUrisByPkArgs, type QueryRootNumActiveDelegatorPerPoolArgs, type QueryRootProcessorStatusArgs, type QueryRootProcessorStatusByPkArgs, type QueryRootProposalVotesAggregateArgs, type QueryRootProposalVotesArgs, type QueryRootProposalVotesByPkArgs, type QueryRootSignaturesArgs, type QueryRootSignaturesByPkArgs, type QueryRootTableItemsArgs, type QueryRootTableItemsByPkArgs, type QueryRootTableMetadatasArgs, type QueryRootTableMetadatasByPkArgs, type QueryRootTokenActivitiesAggregateArgs, type QueryRootTokenActivitiesArgs, type QueryRootTokenActivitiesByPkArgs, type QueryRootTokenActivitiesV2AggregateArgs, type QueryRootTokenActivitiesV2Args, type QueryRootTokenActivitiesV2ByPkArgs, type QueryRootTokenDatasArgs, type QueryRootTokenDatasByPkArgs, type QueryRootTokenOwnershipsArgs, type QueryRootTokenOwnershipsByPkArgs, type QueryRootTokensArgs, type QueryRootTokensByPkArgs, type QueryRootUserTransactionsArgs, type QueryRootUserTransactionsByPkArgs, type Scalars, type Signatures, type SignaturesBoolExp, type SignaturesOrderBy, type SignaturesPublicKeyIndicesArgs, SignaturesSelectColumn, type SignaturesStreamCursorInput, type SignaturesStreamCursorValueInput, type StringComparisonExp, type SubscriptionRoot, type SubscriptionRootAccountTransactionsAggregateArgs, type SubscriptionRootAccountTransactionsArgs, type SubscriptionRootAccountTransactionsByPkArgs, type SubscriptionRootAccountTransactionsStreamArgs, type SubscriptionRootAddressEventsSummaryArgs, type SubscriptionRootAddressEventsSummaryStreamArgs, type SubscriptionRootAddressVersionFromEventsAggregateArgs, type SubscriptionRootAddressVersionFromEventsArgs, type SubscriptionRootAddressVersionFromEventsStreamArgs, type SubscriptionRootAddressVersionFromMoveResourcesAggregateArgs, type SubscriptionRootAddressVersionFromMoveResourcesArgs, type SubscriptionRootAddressVersionFromMoveResourcesStreamArgs, type SubscriptionRootBlockMetadataTransactionsArgs, type SubscriptionRootBlockMetadataTransactionsByPkArgs, type SubscriptionRootBlockMetadataTransactionsStreamArgs, type SubscriptionRootCoinActivitiesAggregateArgs, type SubscriptionRootCoinActivitiesArgs, type SubscriptionRootCoinActivitiesByPkArgs, type SubscriptionRootCoinActivitiesStreamArgs, type SubscriptionRootCoinBalancesArgs, type SubscriptionRootCoinBalancesByPkArgs, type SubscriptionRootCoinBalancesStreamArgs, type SubscriptionRootCoinInfosArgs, type SubscriptionRootCoinInfosByPkArgs, type SubscriptionRootCoinInfosStreamArgs, type SubscriptionRootCoinSupplyArgs, type SubscriptionRootCoinSupplyByPkArgs, type SubscriptionRootCoinSupplyStreamArgs, type SubscriptionRootCollectionDatasArgs, type SubscriptionRootCollectionDatasByPkArgs, type SubscriptionRootCollectionDatasStreamArgs, type SubscriptionRootCurrentAnsLookupArgs, type SubscriptionRootCurrentAnsLookupByPkArgs, type SubscriptionRootCurrentAnsLookupStreamArgs, type SubscriptionRootCurrentAnsLookupV2Args, type SubscriptionRootCurrentAnsLookupV2ByPkArgs, type SubscriptionRootCurrentAnsLookupV2StreamArgs, type SubscriptionRootCurrentAptosNamesAggregateArgs, type SubscriptionRootCurrentAptosNamesArgs, type SubscriptionRootCurrentAptosNamesStreamArgs, type SubscriptionRootCurrentCoinBalancesArgs, type SubscriptionRootCurrentCoinBalancesByPkArgs, type SubscriptionRootCurrentCoinBalancesStreamArgs, type SubscriptionRootCurrentCollectionDatasArgs, type SubscriptionRootCurrentCollectionDatasByPkArgs, type SubscriptionRootCurrentCollectionDatasStreamArgs, type SubscriptionRootCurrentCollectionOwnershipV2ViewAggregateArgs, type SubscriptionRootCurrentCollectionOwnershipV2ViewArgs, type SubscriptionRootCurrentCollectionOwnershipV2ViewStreamArgs, type SubscriptionRootCurrentCollectionsV2Args, type SubscriptionRootCurrentCollectionsV2ByPkArgs, type SubscriptionRootCurrentCollectionsV2StreamArgs, type SubscriptionRootCurrentDelegatedStakingPoolBalancesArgs, type SubscriptionRootCurrentDelegatedStakingPoolBalancesByPkArgs, type SubscriptionRootCurrentDelegatedStakingPoolBalancesStreamArgs, type SubscriptionRootCurrentDelegatedVoterArgs, type SubscriptionRootCurrentDelegatedVoterByPkArgs, type SubscriptionRootCurrentDelegatedVoterStreamArgs, type SubscriptionRootCurrentDelegatorBalancesArgs, type SubscriptionRootCurrentDelegatorBalancesByPkArgs, type SubscriptionRootCurrentDelegatorBalancesStreamArgs, type SubscriptionRootCurrentFungibleAssetBalancesAggregateArgs, type SubscriptionRootCurrentFungibleAssetBalancesArgs, type SubscriptionRootCurrentFungibleAssetBalancesByPkArgs, type SubscriptionRootCurrentFungibleAssetBalancesStreamArgs, type SubscriptionRootCurrentObjectsArgs, type SubscriptionRootCurrentObjectsByPkArgs, type SubscriptionRootCurrentObjectsStreamArgs, type SubscriptionRootCurrentStakingPoolVoterArgs, type SubscriptionRootCurrentStakingPoolVoterByPkArgs, type SubscriptionRootCurrentStakingPoolVoterStreamArgs, type SubscriptionRootCurrentTableItemsArgs, type SubscriptionRootCurrentTableItemsByPkArgs, type SubscriptionRootCurrentTableItemsStreamArgs, type SubscriptionRootCurrentTokenDatasArgs, type SubscriptionRootCurrentTokenDatasByPkArgs, type SubscriptionRootCurrentTokenDatasStreamArgs, type SubscriptionRootCurrentTokenDatasV2Args, type SubscriptionRootCurrentTokenDatasV2ByPkArgs, type SubscriptionRootCurrentTokenDatasV2StreamArgs, type SubscriptionRootCurrentTokenOwnershipsAggregateArgs, type SubscriptionRootCurrentTokenOwnershipsArgs, type SubscriptionRootCurrentTokenOwnershipsByPkArgs, type SubscriptionRootCurrentTokenOwnershipsStreamArgs, type SubscriptionRootCurrentTokenOwnershipsV2AggregateArgs, type SubscriptionRootCurrentTokenOwnershipsV2Args, type SubscriptionRootCurrentTokenOwnershipsV2ByPkArgs, type SubscriptionRootCurrentTokenOwnershipsV2StreamArgs, type SubscriptionRootCurrentTokenPendingClaimsArgs, type SubscriptionRootCurrentTokenPendingClaimsByPkArgs, type SubscriptionRootCurrentTokenPendingClaimsStreamArgs, type SubscriptionRootDelegatedStakingActivitiesArgs, type SubscriptionRootDelegatedStakingActivitiesByPkArgs, type SubscriptionRootDelegatedStakingActivitiesStreamArgs, type SubscriptionRootDelegatedStakingPoolBalancesAggregateArgs, type SubscriptionRootDelegatedStakingPoolBalancesArgs, type SubscriptionRootDelegatedStakingPoolBalancesByPkArgs, type SubscriptionRootDelegatedStakingPoolBalancesStreamArgs, type SubscriptionRootDelegatedStakingPoolsArgs, type SubscriptionRootDelegatedStakingPoolsByPkArgs, type SubscriptionRootDelegatedStakingPoolsStreamArgs, type SubscriptionRootDelegatorDistinctPoolAggregateArgs, type SubscriptionRootDelegatorDistinctPoolArgs, type SubscriptionRootDelegatorDistinctPoolStreamArgs, type SubscriptionRootEventsArgs, type SubscriptionRootEventsByPkArgs, type SubscriptionRootEventsStreamArgs, type SubscriptionRootFungibleAssetActivitiesArgs, type SubscriptionRootFungibleAssetActivitiesByPkArgs, type SubscriptionRootFungibleAssetActivitiesStreamArgs, type SubscriptionRootFungibleAssetMetadataArgs, type SubscriptionRootFungibleAssetMetadataByPkArgs, type SubscriptionRootFungibleAssetMetadataStreamArgs, type SubscriptionRootIndexerStatusArgs, type SubscriptionRootIndexerStatusByPkArgs, type SubscriptionRootIndexerStatusStreamArgs, type SubscriptionRootLedgerInfosArgs, type SubscriptionRootLedgerInfosByPkArgs, type SubscriptionRootLedgerInfosStreamArgs, type SubscriptionRootMoveResourcesAggregateArgs, type SubscriptionRootMoveResourcesArgs, type SubscriptionRootMoveResourcesStreamArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceAuctionsArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceAuctionsByPkArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceAuctionsStreamArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersByPkArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceCollectionOffersStreamArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsAggregateArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsByPkArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceListingsStreamArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersByPkArgs, type SubscriptionRootNftMarketplaceV2CurrentNftMarketplaceTokenOffersStreamArgs, type SubscriptionRootNftMarketplaceV2NftMarketplaceActivitiesArgs, type SubscriptionRootNftMarketplaceV2NftMarketplaceActivitiesByPkArgs, type SubscriptionRootNftMarketplaceV2NftMarketplaceActivitiesStreamArgs, type SubscriptionRootNftMetadataCrawlerParsedAssetUrisArgs, type SubscriptionRootNftMetadataCrawlerParsedAssetUrisByPkArgs, type SubscriptionRootNftMetadataCrawlerParsedAssetUrisStreamArgs, type SubscriptionRootNumActiveDelegatorPerPoolArgs, type SubscriptionRootNumActiveDelegatorPerPoolStreamArgs, type SubscriptionRootProcessorStatusArgs, type SubscriptionRootProcessorStatusByPkArgs, type SubscriptionRootProcessorStatusStreamArgs, type SubscriptionRootProposalVotesAggregateArgs, type SubscriptionRootProposalVotesArgs, type SubscriptionRootProposalVotesByPkArgs, type SubscriptionRootProposalVotesStreamArgs, type SubscriptionRootSignaturesArgs, type SubscriptionRootSignaturesByPkArgs, type SubscriptionRootSignaturesStreamArgs, type SubscriptionRootTableItemsArgs, type SubscriptionRootTableItemsByPkArgs, type SubscriptionRootTableItemsStreamArgs, type SubscriptionRootTableMetadatasArgs, type SubscriptionRootTableMetadatasByPkArgs, type SubscriptionRootTableMetadatasStreamArgs, type SubscriptionRootTokenActivitiesAggregateArgs, type SubscriptionRootTokenActivitiesArgs, type SubscriptionRootTokenActivitiesByPkArgs, type SubscriptionRootTokenActivitiesStreamArgs, type SubscriptionRootTokenActivitiesV2AggregateArgs, type SubscriptionRootTokenActivitiesV2Args, type SubscriptionRootTokenActivitiesV2ByPkArgs, type SubscriptionRootTokenActivitiesV2StreamArgs, type SubscriptionRootTokenDatasArgs, type SubscriptionRootTokenDatasByPkArgs, type SubscriptionRootTokenDatasStreamArgs, type SubscriptionRootTokenOwnershipsArgs, type SubscriptionRootTokenOwnershipsByPkArgs, type SubscriptionRootTokenOwnershipsStreamArgs, type SubscriptionRootTokensArgs, type SubscriptionRootTokensByPkArgs, type SubscriptionRootTokensStreamArgs, type SubscriptionRootUserTransactionsArgs, type SubscriptionRootUserTransactionsByPkArgs, type SubscriptionRootUserTransactionsStreamArgs, type TableItems, type TableItemsBoolExp, type TableItemsDecodedKeyArgs, type TableItemsDecodedValueArgs, type TableItemsOrderBy, TableItemsSelectColumn, type TableItemsStreamCursorInput, type TableItemsStreamCursorValueInput, type TableMetadatas, type TableMetadatasBoolExp, type TableMetadatasOrderBy, TableMetadatasSelectColumn, type TableMetadatasStreamCursorInput, type TableMetadatasStreamCursorValueInput, type TimestampComparisonExp, type TimestamptzComparisonExp, type TokenActivities, type TokenActivitiesAggregate, type TokenActivitiesAggregateBoolExp, type TokenActivitiesAggregateBoolExpCount, type TokenActivitiesAggregateFields, type TokenActivitiesAggregateFieldsCountArgs, type TokenActivitiesAggregateOrderBy, type TokenActivitiesAptosNamesOwnerAggregateArgs, type TokenActivitiesAptosNamesOwnerArgs, type TokenActivitiesAptosNamesToAggregateArgs, type TokenActivitiesAptosNamesToArgs, type TokenActivitiesAvgFields, type TokenActivitiesAvgOrderBy, type TokenActivitiesBoolExp, type TokenActivitiesMaxFields, type TokenActivitiesMaxOrderBy, type TokenActivitiesMinFields, type TokenActivitiesMinOrderBy, type TokenActivitiesOrderBy, TokenActivitiesSelectColumn, type TokenActivitiesStddevFields, type TokenActivitiesStddevOrderBy, type TokenActivitiesStddevPopFields, type TokenActivitiesStddevPopOrderBy, type TokenActivitiesStddevSampFields, type TokenActivitiesStddevSampOrderBy, type TokenActivitiesStreamCursorInput, type TokenActivitiesStreamCursorValueInput, type TokenActivitiesSumFields, type TokenActivitiesSumOrderBy, type TokenActivitiesV2, type TokenActivitiesV2Aggregate, type TokenActivitiesV2AggregateBoolExp, type TokenActivitiesV2AggregateBoolExpBoolAnd, type TokenActivitiesV2AggregateBoolExpBoolOr, type TokenActivitiesV2AggregateBoolExpCount, type TokenActivitiesV2AggregateFields, type TokenActivitiesV2AggregateFieldsCountArgs, type TokenActivitiesV2AggregateOrderBy, type TokenActivitiesV2AptosNamesFromAggregateArgs, type TokenActivitiesV2AptosNamesFromArgs, type TokenActivitiesV2AptosNamesToAggregateArgs, type TokenActivitiesV2AptosNamesToArgs, type TokenActivitiesV2AvgFields, type TokenActivitiesV2AvgOrderBy, type TokenActivitiesV2BoolExp, type TokenActivitiesV2MaxFields, type TokenActivitiesV2MaxOrderBy, type TokenActivitiesV2MinFields, type TokenActivitiesV2MinOrderBy, type TokenActivitiesV2OrderBy, TokenActivitiesV2SelectColumn, TokenActivitiesV2SelectColumnTokenActivitiesV2AggregateBoolExpBoolAndArgumentsColumns, TokenActivitiesV2SelectColumnTokenActivitiesV2AggregateBoolExpBoolOrArgumentsColumns, type TokenActivitiesV2StddevFields, type TokenActivitiesV2StddevOrderBy, type TokenActivitiesV2StddevPopFields, type TokenActivitiesV2StddevPopOrderBy, type TokenActivitiesV2StddevSampFields, type TokenActivitiesV2StddevSampOrderBy, type TokenActivitiesV2StreamCursorInput, type TokenActivitiesV2StreamCursorValueInput, type TokenActivitiesV2SumFields, type TokenActivitiesV2SumOrderBy, type TokenActivitiesV2VarPopFields, type TokenActivitiesV2VarPopOrderBy, type TokenActivitiesV2VarSampFields, type TokenActivitiesV2VarSampOrderBy, type TokenActivitiesV2VarianceFields, type TokenActivitiesV2VarianceOrderBy, type TokenActivitiesVarPopFields, type TokenActivitiesVarPopOrderBy, type TokenActivitiesVarSampFields, type TokenActivitiesVarSampOrderBy, type TokenActivitiesVarianceFields, type TokenActivitiesVarianceOrderBy, type TokenDatas, type TokenDatasBoolExp, type TokenDatasDefaultPropertiesArgs, type TokenDatasOrderBy, TokenDatasSelectColumn, type TokenDatasStreamCursorInput, type TokenDatasStreamCursorValueInput, type TokenOwnerships, type TokenOwnershipsBoolExp, type TokenOwnershipsOrderBy, TokenOwnershipsSelectColumn, type TokenOwnershipsStreamCursorInput, type TokenOwnershipsStreamCursorValueInput, type Tokens, type TokensBoolExp, type TokensOrderBy, TokensSelectColumn, type TokensStreamCursorInput, type TokensStreamCursorValueInput, type TokensTokenPropertiesArgs, type UserTransactions, type UserTransactionsBoolExp, type UserTransactionsOrderBy, UserTransactionsSelectColumn, type UserTransactionsStreamCursorInput, type UserTransactionsStreamCursorValueInput };