@fewcha/aptos/src/indexer/generated/types.ts

Aptos SDK

export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  bigint: any;
  jsonb: any;
  numeric: any;
  timestamp: any;
};

/** Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'. */
export type Boolean_Comparison_Exp = {
  _eq?: InputMaybe<Scalars["Boolean"]>;
  _gt?: InputMaybe<Scalars["Boolean"]>;
  _gte?: InputMaybe<Scalars["Boolean"]>;
  _in?: InputMaybe<Array<Scalars["Boolean"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]>;
  _lt?: InputMaybe<Scalars["Boolean"]>;
  _lte?: InputMaybe<Scalars["Boolean"]>;
  _neq?: InputMaybe<Scalars["Boolean"]>;
  _nin?: InputMaybe<Array<Scalars["Boolean"]>>;
};

/** Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'. */
export type Int_Comparison_Exp = {
  _eq?: InputMaybe<Scalars["Int"]>;
  _gt?: InputMaybe<Scalars["Int"]>;
  _gte?: InputMaybe<Scalars["Int"]>;
  _in?: InputMaybe<Array<Scalars["Int"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]>;
  _lt?: InputMaybe<Scalars["Int"]>;
  _lte?: InputMaybe<Scalars["Int"]>;
  _neq?: InputMaybe<Scalars["Int"]>;
  _nin?: InputMaybe<Array<Scalars["Int"]>>;
};

/** Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'. */
export type String_Comparison_Exp = {
  _eq?: InputMaybe<Scalars["String"]>;
  _gt?: InputMaybe<Scalars["String"]>;
  _gte?: InputMaybe<Scalars["String"]>;
  /** does the column match the given case-insensitive pattern */
  _ilike?: InputMaybe<Scalars["String"]>;
  _in?: InputMaybe<Array<Scalars["String"]>>;
  /** does the column match the given POSIX regular expression, case insensitive */
  _iregex?: InputMaybe<Scalars["String"]>;
  _is_null?: InputMaybe<Scalars["Boolean"]>;
  /** does the column match the given pattern */
  _like?: InputMaybe<Scalars["String"]>;
  _lt?: InputMaybe<Scalars["String"]>;
  _lte?: InputMaybe<Scalars["String"]>;
  _neq?: InputMaybe<Scalars["String"]>;
  /** does the column NOT match the given case-insensitive pattern */
  _nilike?: InputMaybe<Scalars["String"]>;
  _nin?: InputMaybe<Array<Scalars["String"]>>;
  /** does the column NOT match the given POSIX regular expression, case insensitive */
  _niregex?: InputMaybe<Scalars["String"]>;
  /** does the column NOT match the given pattern */
  _nlike?: InputMaybe<Scalars["String"]>;
  /** does the column NOT match the given POSIX regular expression, case sensitive */
  _nregex?: InputMaybe<Scalars["String"]>;
  /** does the column NOT match the given SQL regular expression */
  _nsimilar?: InputMaybe<Scalars["String"]>;
  /** does the column match the given POSIX regular expression, case sensitive */
  _regex?: InputMaybe<Scalars["String"]>;
  /** does the column match the given SQL regular expression */
  _similar?: InputMaybe<Scalars["String"]>;
};

/** columns and relationships of "address_events_summary" */
export type Address_Events_Summary = {
  __typename?: "address_events_summary";
  account_address?: Maybe<Scalars["String"]>;
  /** An object relationship */
  block_metadata?: Maybe<Block_Metadata_Transactions>;
  min_block_height?: Maybe<Scalars["bigint"]>;
  num_distinct_versions?: Maybe<Scalars["bigint"]>;
};

/** Boolean expression to filter rows from the table "address_events_summary". All fields are combined with a logical 'AND'. */
export type Address_Events_Summary_Bool_Exp = {
  _and?: InputMaybe<Array<Address_Events_Summary_Bool_Exp>>;
  _not?: InputMaybe<Address_Events_Summary_Bool_Exp>;
  _or?: InputMaybe<Array<Address_Events_Summary_Bool_Exp>>;
  account_address?: InputMaybe<String_Comparison_Exp>;
  block_metadata?: InputMaybe<Block_Metadata_Transactions_Bool_Exp>;
  min_block_height?: InputMaybe<Bigint_Comparison_Exp>;
  num_distinct_versions?: InputMaybe<Bigint_Comparison_Exp>;
};

/** Ordering options when selecting data from "address_events_summary". */
export type Address_Events_Summary_Order_By = {
  account_address?: InputMaybe<Order_By>;
  block_metadata?: InputMaybe<Block_Metadata_Transactions_Order_By>;
  min_block_height?: InputMaybe<Order_By>;
  num_distinct_versions?: InputMaybe<Order_By>;
};

/** select columns of table "address_events_summary" */
export enum Address_Events_Summary_Select_Column {
  /** 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" */
export type Address_Events_Summary_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Address_Events_Summary_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Address_Events_Summary_Stream_Cursor_Value_Input = {
  account_address?: InputMaybe<Scalars["String"]>;
  min_block_height?: InputMaybe<Scalars["bigint"]>;
  num_distinct_versions?: InputMaybe<Scalars["bigint"]>;
};

/** columns and relationships of "address_version_from_events" */
export type Address_Version_From_Events = {
  __typename?: "address_version_from_events";
  account_address?: Maybe<Scalars["String"]>;
  coin_activities: Array<Coin_Activities>;
  coin_activities_aggregate: Coin_Activities_Aggregate;
  token_activities: Array<Token_Activities>;
  token_activities_aggregate: Token_Activities_Aggregate;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** columns and relationships of "address_version_from_events" */
export type Address_Version_From_EventsCoin_ActivitiesArgs = {
  distinct_on?: InputMaybe<Array<Coin_Activities_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Coin_Activities_Order_By>>;
  where?: InputMaybe<Coin_Activities_Bool_Exp>;
};

/** columns and relationships of "address_version_from_events" */
export type Address_Version_From_EventsCoin_Activities_AggregateArgs = {
  distinct_on?: InputMaybe<Array<Coin_Activities_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Coin_Activities_Order_By>>;
  where?: InputMaybe<Coin_Activities_Bool_Exp>;
};

/** columns and relationships of "address_version_from_events" */
export type Address_Version_From_EventsToken_ActivitiesArgs = {
  distinct_on?: InputMaybe<Array<Token_Activities_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Token_Activities_Order_By>>;
  where?: InputMaybe<Token_Activities_Bool_Exp>;
};

/** columns and relationships of "address_version_from_events" */
export type Address_Version_From_EventsToken_Activities_AggregateArgs = {
  distinct_on?: InputMaybe<Array<Token_Activities_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Token_Activities_Order_By>>;
  where?: InputMaybe<Token_Activities_Bool_Exp>;
};

/** aggregated selection of "address_version_from_events" */
export type Address_Version_From_Events_Aggregate = {
  __typename?: "address_version_from_events_aggregate";
  aggregate?: Maybe<Address_Version_From_Events_Aggregate_Fields>;
  nodes: Array<Address_Version_From_Events>;
};

/** aggregate fields of "address_version_from_events" */
export type Address_Version_From_Events_Aggregate_Fields = {
  __typename?: "address_version_from_events_aggregate_fields";
  avg?: Maybe<Address_Version_From_Events_Avg_Fields>;
  count: Scalars["Int"];
  max?: Maybe<Address_Version_From_Events_Max_Fields>;
  min?: Maybe<Address_Version_From_Events_Min_Fields>;
  stddev?: Maybe<Address_Version_From_Events_Stddev_Fields>;
  stddev_pop?: Maybe<Address_Version_From_Events_Stddev_Pop_Fields>;
  stddev_samp?: Maybe<Address_Version_From_Events_Stddev_Samp_Fields>;
  sum?: Maybe<Address_Version_From_Events_Sum_Fields>;
  var_pop?: Maybe<Address_Version_From_Events_Var_Pop_Fields>;
  var_samp?: Maybe<Address_Version_From_Events_Var_Samp_Fields>;
  variance?: Maybe<Address_Version_From_Events_Variance_Fields>;
};

/** aggregate fields of "address_version_from_events" */
export type Address_Version_From_Events_Aggregate_FieldsCountArgs = {
  columns?: InputMaybe<Array<Address_Version_From_Events_Select_Column>>;
  distinct?: InputMaybe<Scalars["Boolean"]>;
};

/** aggregate avg on columns */
export type Address_Version_From_Events_Avg_Fields = {
  __typename?: "address_version_from_events_avg_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** Boolean expression to filter rows from the table "address_version_from_events". All fields are combined with a logical 'AND'. */
export type Address_Version_From_Events_Bool_Exp = {
  _and?: InputMaybe<Array<Address_Version_From_Events_Bool_Exp>>;
  _not?: InputMaybe<Address_Version_From_Events_Bool_Exp>;
  _or?: InputMaybe<Array<Address_Version_From_Events_Bool_Exp>>;
  account_address?: InputMaybe<String_Comparison_Exp>;
  transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
};

/** aggregate max on columns */
export type Address_Version_From_Events_Max_Fields = {
  __typename?: "address_version_from_events_max_fields";
  account_address?: Maybe<Scalars["String"]>;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** aggregate min on columns */
export type Address_Version_From_Events_Min_Fields = {
  __typename?: "address_version_from_events_min_fields";
  account_address?: Maybe<Scalars["String"]>;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** Ordering options when selecting data from "address_version_from_events". */
export type Address_Version_From_Events_Order_By = {
  account_address?: InputMaybe<Order_By>;
  transaction_version?: InputMaybe<Order_By>;
};

/** select columns of table "address_version_from_events" */
export enum Address_Version_From_Events_Select_Column {
  /** column name */
  AccountAddress = "account_address",
  /** column name */
  TransactionVersion = "transaction_version",
}

/** aggregate stddev on columns */
export type Address_Version_From_Events_Stddev_Fields = {
  __typename?: "address_version_from_events_stddev_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate stddev_pop on columns */
export type Address_Version_From_Events_Stddev_Pop_Fields = {
  __typename?: "address_version_from_events_stddev_pop_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate stddev_samp on columns */
export type Address_Version_From_Events_Stddev_Samp_Fields = {
  __typename?: "address_version_from_events_stddev_samp_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** Streaming cursor of the table "address_version_from_events" */
export type Address_Version_From_Events_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Address_Version_From_Events_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Address_Version_From_Events_Stream_Cursor_Value_Input = {
  account_address?: InputMaybe<Scalars["String"]>;
  transaction_version?: InputMaybe<Scalars["bigint"]>;
};

/** aggregate sum on columns */
export type Address_Version_From_Events_Sum_Fields = {
  __typename?: "address_version_from_events_sum_fields";
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** aggregate var_pop on columns */
export type Address_Version_From_Events_Var_Pop_Fields = {
  __typename?: "address_version_from_events_var_pop_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate var_samp on columns */
export type Address_Version_From_Events_Var_Samp_Fields = {
  __typename?: "address_version_from_events_var_samp_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate variance on columns */
export type Address_Version_From_Events_Variance_Fields = {
  __typename?: "address_version_from_events_variance_fields";
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** columns and relationships of "address_version_from_move_resources" */
export type Address_Version_From_Move_Resources = {
  __typename?: "address_version_from_move_resources";
  address?: Maybe<Scalars["String"]>;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** Boolean expression to filter rows from the table "address_version_from_move_resources". All fields are combined with a logical 'AND'. */
export type Address_Version_From_Move_Resources_Bool_Exp = {
  _and?: InputMaybe<Array<Address_Version_From_Move_Resources_Bool_Exp>>;
  _not?: InputMaybe<Address_Version_From_Move_Resources_Bool_Exp>;
  _or?: InputMaybe<Array<Address_Version_From_Move_Resources_Bool_Exp>>;
  address?: InputMaybe<String_Comparison_Exp>;
  transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
};

/** Ordering options when selecting data from "address_version_from_move_resources". */
export type Address_Version_From_Move_Resources_Order_By = {
  address?: InputMaybe<Order_By>;
  transaction_version?: InputMaybe<Order_By>;
};

/** select columns of table "address_version_from_move_resources" */
export enum Address_Version_From_Move_Resources_Select_Column {
  /** column name */
  Address = "address",
  /** column name */
  TransactionVersion = "transaction_version",
}

/** Streaming cursor of the table "address_version_from_move_resources" */
export type Address_Version_From_Move_Resources_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Address_Version_From_Move_Resources_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Address_Version_From_Move_Resources_Stream_Cursor_Value_Input = {
  address?: InputMaybe<Scalars["String"]>;
  transaction_version?: InputMaybe<Scalars["bigint"]>;
};

/** Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'. */
export type Bigint_Comparison_Exp = {
  _eq?: InputMaybe<Scalars["bigint"]>;
  _gt?: InputMaybe<Scalars["bigint"]>;
  _gte?: InputMaybe<Scalars["bigint"]>;
  _in?: InputMaybe<Array<Scalars["bigint"]>>;
  _is_null?: InputMaybe<Scalars["Boolean"]>;
  _lt?: InputMaybe<Scalars["bigint"]>;
  _lte?: InputMaybe<Scalars["bigint"]>;
  _neq?: InputMaybe<Scalars["bigint"]>;
  _nin?: InputMaybe<Array<Scalars["bigint"]>>;
};

/** columns and relationships of "block_metadata_transactions" */
export type Block_Metadata_Transactions = {
  __typename?: "block_metadata_transactions";
  block_height: Scalars["bigint"];
  epoch: Scalars["bigint"];
  failed_proposer_indices: Scalars["jsonb"];
  id: Scalars["String"];
  previous_block_votes_bitvec: Scalars["jsonb"];
  proposer: Scalars["String"];
  round: Scalars["bigint"];
  timestamp: Scalars["timestamp"];
  version: Scalars["bigint"];
};

/** columns and relationships of "block_metadata_transactions" */
export type Block_Metadata_TransactionsFailed_Proposer_IndicesArgs = {
  path?: InputMaybe<Scalars["String"]>;
};

/** columns and relationships of "block_metadata_transactions" */
export type Block_Metadata_TransactionsPrevious_Block_Votes_BitvecArgs = {
  path?: InputMaybe<Scalars["String"]>;
};

/** Boolean expression to filter rows from the table "block_metadata_transactions". All fields are combined with a logical 'AND'. */
export type Block_Metadata_Transactions_Bool_Exp = {
  _and?: InputMaybe<Array<Block_Metadata_Transactions_Bool_Exp>>;
  _not?: InputMaybe<Block_Metadata_Transactions_Bool_Exp>;
  _or?: InputMaybe<Array<Block_Metadata_Transactions_Bool_Exp>>;
  block_height?: InputMaybe<Bigint_Comparison_Exp>;
  epoch?: InputMaybe<Bigint_Comparison_Exp>;
  failed_proposer_indices?: InputMaybe<Jsonb_Comparison_Exp>;
  id?: InputMaybe<String_Comparison_Exp>;
  previous_block_votes_bitvec?: InputMaybe<Jsonb_Comparison_Exp>;
  proposer?: InputMaybe<String_Comparison_Exp>;
  round?: InputMaybe<Bigint_Comparison_Exp>;
  timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  version?: InputMaybe<Bigint_Comparison_Exp>;
};

/** Ordering options when selecting data from "block_metadata_transactions". */
export type Block_Metadata_Transactions_Order_By = {
  block_height?: InputMaybe<Order_By>;
  epoch?: InputMaybe<Order_By>;
  failed_proposer_indices?: InputMaybe<Order_By>;
  id?: InputMaybe<Order_By>;
  previous_block_votes_bitvec?: InputMaybe<Order_By>;
  proposer?: InputMaybe<Order_By>;
  round?: InputMaybe<Order_By>;
  timestamp?: InputMaybe<Order_By>;
  version?: InputMaybe<Order_By>;
};

/** select columns of table "block_metadata_transactions" */
export enum Block_Metadata_Transactions_Select_Column {
  /** 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" */
export type Block_Metadata_Transactions_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Block_Metadata_Transactions_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Block_Metadata_Transactions_Stream_Cursor_Value_Input = {
  block_height?: InputMaybe<Scalars["bigint"]>;
  epoch?: InputMaybe<Scalars["bigint"]>;
  failed_proposer_indices?: InputMaybe<Scalars["jsonb"]>;
  id?: InputMaybe<Scalars["String"]>;
  previous_block_votes_bitvec?: InputMaybe<Scalars["jsonb"]>;
  proposer?: InputMaybe<Scalars["String"]>;
  round?: InputMaybe<Scalars["bigint"]>;
  timestamp?: InputMaybe<Scalars["timestamp"]>;
  version?: InputMaybe<Scalars["bigint"]>;
};

/** columns and relationships of "coin_activities" */
export type Coin_Activities = {
  __typename?: "coin_activities";
  activity_type: Scalars["String"];
  amount: Scalars["numeric"];
  /** An array relationship */
  aptos_names: Array<Current_Ans_Lookup>;
  block_height: Scalars["bigint"];
  /** An object relationship */
  coin_info?: Maybe<Coin_Infos>;
  coin_type: Scalars["String"];
  entry_function_id_str?: Maybe<Scalars["String"]>;
  event_account_address: Scalars["String"];
  event_creation_number: Scalars["bigint"];
  event_index?: Maybe<Scalars["bigint"]>;
  event_sequence_number: Scalars["bigint"];
  is_gas_fee: Scalars["Boolean"];
  is_transaction_success: Scalars["Boolean"];
  owner_address: Scalars["String"];
  transaction_timestamp: Scalars["timestamp"];
  transaction_version: Scalars["bigint"];
};

/** columns and relationships of "coin_activities" */
export type Coin_ActivitiesAptos_NamesArgs = {
  distinct_on?: InputMaybe<Array<Current_Ans_Lookup_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Current_Ans_Lookup_Order_By>>;
  where?: InputMaybe<Current_Ans_Lookup_Bool_Exp>;
};

/** aggregated selection of "coin_activities" */
export type Coin_Activities_Aggregate = {
  __typename?: "coin_activities_aggregate";
  aggregate?: Maybe<Coin_Activities_Aggregate_Fields>;
  nodes: Array<Coin_Activities>;
};

/** aggregate fields of "coin_activities" */
export type Coin_Activities_Aggregate_Fields = {
  __typename?: "coin_activities_aggregate_fields";
  avg?: Maybe<Coin_Activities_Avg_Fields>;
  count: Scalars["Int"];
  max?: Maybe<Coin_Activities_Max_Fields>;
  min?: Maybe<Coin_Activities_Min_Fields>;
  stddev?: Maybe<Coin_Activities_Stddev_Fields>;
  stddev_pop?: Maybe<Coin_Activities_Stddev_Pop_Fields>;
  stddev_samp?: Maybe<Coin_Activities_Stddev_Samp_Fields>;
  sum?: Maybe<Coin_Activities_Sum_Fields>;
  var_pop?: Maybe<Coin_Activities_Var_Pop_Fields>;
  var_samp?: Maybe<Coin_Activities_Var_Samp_Fields>;
  variance?: Maybe<Coin_Activities_Variance_Fields>;
};

/** aggregate fields of "coin_activities" */
export type Coin_Activities_Aggregate_FieldsCountArgs = {
  columns?: InputMaybe<Array<Coin_Activities_Select_Column>>;
  distinct?: InputMaybe<Scalars["Boolean"]>;
};

/** aggregate avg on columns */
export type Coin_Activities_Avg_Fields = {
  __typename?: "coin_activities_avg_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** Boolean expression to filter rows from the table "coin_activities". All fields are combined with a logical 'AND'. */
export type Coin_Activities_Bool_Exp = {
  _and?: InputMaybe<Array<Coin_Activities_Bool_Exp>>;
  _not?: InputMaybe<Coin_Activities_Bool_Exp>;
  _or?: InputMaybe<Array<Coin_Activities_Bool_Exp>>;
  activity_type?: InputMaybe<String_Comparison_Exp>;
  amount?: InputMaybe<Numeric_Comparison_Exp>;
  aptos_names?: InputMaybe<Current_Ans_Lookup_Bool_Exp>;
  block_height?: InputMaybe<Bigint_Comparison_Exp>;
  coin_info?: InputMaybe<Coin_Infos_Bool_Exp>;
  coin_type?: InputMaybe<String_Comparison_Exp>;
  entry_function_id_str?: InputMaybe<String_Comparison_Exp>;
  event_account_address?: InputMaybe<String_Comparison_Exp>;
  event_creation_number?: InputMaybe<Bigint_Comparison_Exp>;
  event_index?: InputMaybe<Bigint_Comparison_Exp>;
  event_sequence_number?: InputMaybe<Bigint_Comparison_Exp>;
  is_gas_fee?: InputMaybe<Boolean_Comparison_Exp>;
  is_transaction_success?: InputMaybe<Boolean_Comparison_Exp>;
  owner_address?: InputMaybe<String_Comparison_Exp>;
  transaction_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
};

/** aggregate max on columns */
export type Coin_Activities_Max_Fields = {
  __typename?: "coin_activities_max_fields";
  activity_type?: Maybe<Scalars["String"]>;
  amount?: Maybe<Scalars["numeric"]>;
  block_height?: Maybe<Scalars["bigint"]>;
  coin_type?: Maybe<Scalars["String"]>;
  entry_function_id_str?: Maybe<Scalars["String"]>;
  event_account_address?: Maybe<Scalars["String"]>;
  event_creation_number?: Maybe<Scalars["bigint"]>;
  event_index?: Maybe<Scalars["bigint"]>;
  event_sequence_number?: Maybe<Scalars["bigint"]>;
  owner_address?: Maybe<Scalars["String"]>;
  transaction_timestamp?: Maybe<Scalars["timestamp"]>;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** aggregate min on columns */
export type Coin_Activities_Min_Fields = {
  __typename?: "coin_activities_min_fields";
  activity_type?: Maybe<Scalars["String"]>;
  amount?: Maybe<Scalars["numeric"]>;
  block_height?: Maybe<Scalars["bigint"]>;
  coin_type?: Maybe<Scalars["String"]>;
  entry_function_id_str?: Maybe<Scalars["String"]>;
  event_account_address?: Maybe<Scalars["String"]>;
  event_creation_number?: Maybe<Scalars["bigint"]>;
  event_index?: Maybe<Scalars["bigint"]>;
  event_sequence_number?: Maybe<Scalars["bigint"]>;
  owner_address?: Maybe<Scalars["String"]>;
  transaction_timestamp?: Maybe<Scalars["timestamp"]>;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** Ordering options when selecting data from "coin_activities". */
export type Coin_Activities_Order_By = {
  activity_type?: InputMaybe<Order_By>;
  amount?: InputMaybe<Order_By>;
  aptos_names_aggregate?: InputMaybe<Current_Ans_Lookup_Aggregate_Order_By>;
  block_height?: InputMaybe<Order_By>;
  coin_info?: InputMaybe<Coin_Infos_Order_By>;
  coin_type?: InputMaybe<Order_By>;
  entry_function_id_str?: InputMaybe<Order_By>;
  event_account_address?: InputMaybe<Order_By>;
  event_creation_number?: InputMaybe<Order_By>;
  event_index?: InputMaybe<Order_By>;
  event_sequence_number?: InputMaybe<Order_By>;
  is_gas_fee?: InputMaybe<Order_By>;
  is_transaction_success?: InputMaybe<Order_By>;
  owner_address?: InputMaybe<Order_By>;
  transaction_timestamp?: InputMaybe<Order_By>;
  transaction_version?: InputMaybe<Order_By>;
};

/** select columns of table "coin_activities" */
export enum Coin_Activities_Select_Column {
  /** 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 */
  TransactionTimestamp = "transaction_timestamp",
  /** column name */
  TransactionVersion = "transaction_version",
}

/** aggregate stddev on columns */
export type Coin_Activities_Stddev_Fields = {
  __typename?: "coin_activities_stddev_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate stddev_pop on columns */
export type Coin_Activities_Stddev_Pop_Fields = {
  __typename?: "coin_activities_stddev_pop_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate stddev_samp on columns */
export type Coin_Activities_Stddev_Samp_Fields = {
  __typename?: "coin_activities_stddev_samp_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** Streaming cursor of the table "coin_activities" */
export type Coin_Activities_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Coin_Activities_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Coin_Activities_Stream_Cursor_Value_Input = {
  activity_type?: InputMaybe<Scalars["String"]>;
  amount?: InputMaybe<Scalars["numeric"]>;
  block_height?: InputMaybe<Scalars["bigint"]>;
  coin_type?: InputMaybe<Scalars["String"]>;
  entry_function_id_str?: InputMaybe<Scalars["String"]>;
  event_account_address?: InputMaybe<Scalars["String"]>;
  event_creation_number?: InputMaybe<Scalars["bigint"]>;
  event_index?: InputMaybe<Scalars["bigint"]>;
  event_sequence_number?: InputMaybe<Scalars["bigint"]>;
  is_gas_fee?: InputMaybe<Scalars["Boolean"]>;
  is_transaction_success?: InputMaybe<Scalars["Boolean"]>;
  owner_address?: InputMaybe<Scalars["String"]>;
  transaction_timestamp?: InputMaybe<Scalars["timestamp"]>;
  transaction_version?: InputMaybe<Scalars["bigint"]>;
};

/** aggregate sum on columns */
export type Coin_Activities_Sum_Fields = {
  __typename?: "coin_activities_sum_fields";
  amount?: Maybe<Scalars["numeric"]>;
  block_height?: Maybe<Scalars["bigint"]>;
  event_creation_number?: Maybe<Scalars["bigint"]>;
  event_index?: Maybe<Scalars["bigint"]>;
  event_sequence_number?: Maybe<Scalars["bigint"]>;
  transaction_version?: Maybe<Scalars["bigint"]>;
};

/** aggregate var_pop on columns */
export type Coin_Activities_Var_Pop_Fields = {
  __typename?: "coin_activities_var_pop_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate var_samp on columns */
export type Coin_Activities_Var_Samp_Fields = {
  __typename?: "coin_activities_var_samp_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** aggregate variance on columns */
export type Coin_Activities_Variance_Fields = {
  __typename?: "coin_activities_variance_fields";
  amount?: Maybe<Scalars["Float"]>;
  block_height?: Maybe<Scalars["Float"]>;
  event_creation_number?: Maybe<Scalars["Float"]>;
  event_index?: Maybe<Scalars["Float"]>;
  event_sequence_number?: Maybe<Scalars["Float"]>;
  transaction_version?: Maybe<Scalars["Float"]>;
};

/** columns and relationships of "coin_balances" */
export type Coin_Balances = {
  __typename?: "coin_balances";
  amount: Scalars["numeric"];
  coin_type: Scalars["String"];
  coin_type_hash: Scalars["String"];
  owner_address: Scalars["String"];
  transaction_timestamp: Scalars["timestamp"];
  transaction_version: Scalars["bigint"];
};

/** Boolean expression to filter rows from the table "coin_balances". All fields are combined with a logical 'AND'. */
export type Coin_Balances_Bool_Exp = {
  _and?: InputMaybe<Array<Coin_Balances_Bool_Exp>>;
  _not?: InputMaybe<Coin_Balances_Bool_Exp>;
  _or?: InputMaybe<Array<Coin_Balances_Bool_Exp>>;
  amount?: InputMaybe<Numeric_Comparison_Exp>;
  coin_type?: InputMaybe<String_Comparison_Exp>;
  coin_type_hash?: InputMaybe<String_Comparison_Exp>;
  owner_address?: InputMaybe<String_Comparison_Exp>;
  transaction_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
};

/** Ordering options when selecting data from "coin_balances". */
export type Coin_Balances_Order_By = {
  amount?: InputMaybe<Order_By>;
  coin_type?: InputMaybe<Order_By>;
  coin_type_hash?: InputMaybe<Order_By>;
  owner_address?: InputMaybe<Order_By>;
  transaction_timestamp?: InputMaybe<Order_By>;
  transaction_version?: InputMaybe<Order_By>;
};

/** select columns of table "coin_balances" */
export enum Coin_Balances_Select_Column {
  /** 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" */
export type Coin_Balances_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Coin_Balances_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Coin_Balances_Stream_Cursor_Value_Input = {
  amount?: InputMaybe<Scalars["numeric"]>;
  coin_type?: InputMaybe<Scalars["String"]>;
  coin_type_hash?: InputMaybe<Scalars["String"]>;
  owner_address?: InputMaybe<Scalars["String"]>;
  transaction_timestamp?: InputMaybe<Scalars["timestamp"]>;
  transaction_version?: InputMaybe<Scalars["bigint"]>;
};

/** columns and relationships of "coin_infos" */
export type Coin_Infos = {
  __typename?: "coin_infos";
  coin_type: Scalars["String"];
  coin_type_hash: Scalars["String"];
  creator_address: Scalars["String"];
  decimals: Scalars["Int"];
  name: Scalars["String"];
  supply_aggregator_table_handle?: Maybe<Scalars["String"]>;
  supply_aggregator_table_key?: Maybe<Scalars["String"]>;
  symbol: Scalars["String"];
  transaction_created_timestamp: Scalars["timestamp"];
  transaction_version_created: Scalars["bigint"];
};

/** Boolean expression to filter rows from the table "coin_infos". All fields are combined with a logical 'AND'. */
export type Coin_Infos_Bool_Exp = {
  _and?: InputMaybe<Array<Coin_Infos_Bool_Exp>>;
  _not?: InputMaybe<Coin_Infos_Bool_Exp>;
  _or?: InputMaybe<Array<Coin_Infos_Bool_Exp>>;
  coin_type?: InputMaybe<String_Comparison_Exp>;
  coin_type_hash?: InputMaybe<String_Comparison_Exp>;
  creator_address?: InputMaybe<String_Comparison_Exp>;
  decimals?: InputMaybe<Int_Comparison_Exp>;
  name?: InputMaybe<String_Comparison_Exp>;
  supply_aggregator_table_handle?: InputMaybe<String_Comparison_Exp>;
  supply_aggregator_table_key?: InputMaybe<String_Comparison_Exp>;
  symbol?: InputMaybe<String_Comparison_Exp>;
  transaction_created_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  transaction_version_created?: InputMaybe<Bigint_Comparison_Exp>;
};

/** Ordering options when selecting data from "coin_infos". */
export type Coin_Infos_Order_By = {
  coin_type?: InputMaybe<Order_By>;
  coin_type_hash?: InputMaybe<Order_By>;
  creator_address?: InputMaybe<Order_By>;
  decimals?: InputMaybe<Order_By>;
  name?: InputMaybe<Order_By>;
  supply_aggregator_table_handle?: InputMaybe<Order_By>;
  supply_aggregator_table_key?: InputMaybe<Order_By>;
  symbol?: InputMaybe<Order_By>;
  transaction_created_timestamp?: InputMaybe<Order_By>;
  transaction_version_created?: InputMaybe<Order_By>;
};

/** select columns of table "coin_infos" */
export enum Coin_Infos_Select_Column {
  /** 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" */
export type Coin_Infos_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Coin_Infos_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Coin_Infos_Stream_Cursor_Value_Input = {
  coin_type?: InputMaybe<Scalars["String"]>;
  coin_type_hash?: InputMaybe<Scalars["String"]>;
  creator_address?: InputMaybe<Scalars["String"]>;
  decimals?: InputMaybe<Scalars["Int"]>;
  name?: InputMaybe<Scalars["String"]>;
  supply_aggregator_table_handle?: InputMaybe<Scalars["String"]>;
  supply_aggregator_table_key?: InputMaybe<Scalars["String"]>;
  symbol?: InputMaybe<Scalars["String"]>;
  transaction_created_timestamp?: InputMaybe<Scalars["timestamp"]>;
  transaction_version_created?: InputMaybe<Scalars["bigint"]>;
};

/** columns and relationships of "coin_supply" */
export type Coin_Supply = {
  __typename?: "coin_supply";
  coin_type: Scalars["String"];
  coin_type_hash: Scalars["String"];
  supply: Scalars["numeric"];
  transaction_epoch: Scalars["bigint"];
  transaction_timestamp: Scalars["timestamp"];
  transaction_version: Scalars["bigint"];
};

/** Boolean expression to filter rows from the table "coin_supply". All fields are combined with a logical 'AND'. */
export type Coin_Supply_Bool_Exp = {
  _and?: InputMaybe<Array<Coin_Supply_Bool_Exp>>;
  _not?: InputMaybe<Coin_Supply_Bool_Exp>;
  _or?: InputMaybe<Array<Coin_Supply_Bool_Exp>>;
  coin_type?: InputMaybe<String_Comparison_Exp>;
  coin_type_hash?: InputMaybe<String_Comparison_Exp>;
  supply?: InputMaybe<Numeric_Comparison_Exp>;
  transaction_epoch?: InputMaybe<Bigint_Comparison_Exp>;
  transaction_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
};

/** Ordering options when selecting data from "coin_supply". */
export type Coin_Supply_Order_By = {
  coin_type?: InputMaybe<Order_By>;
  coin_type_hash?: InputMaybe<Order_By>;
  supply?: InputMaybe<Order_By>;
  transaction_epoch?: InputMaybe<Order_By>;
  transaction_timestamp?: InputMaybe<Order_By>;
  transaction_version?: InputMaybe<Order_By>;
};

/** select columns of table "coin_supply" */
export enum Coin_Supply_Select_Column {
  /** 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" */
export type Coin_Supply_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Coin_Supply_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Coin_Supply_Stream_Cursor_Value_Input = {
  coin_type?: InputMaybe<Scalars["String"]>;
  coin_type_hash?: InputMaybe<Scalars["String"]>;
  supply?: InputMaybe<Scalars["numeric"]>;
  transaction_epoch?: InputMaybe<Scalars["bigint"]>;
  transaction_timestamp?: InputMaybe<Scalars["timestamp"]>;
  transaction_version?: InputMaybe<Scalars["bigint"]>;
};

/** columns and relationships of "collection_datas" */
export type Collection_Datas = {
  __typename?: "collection_datas";
  collection_data_id_hash: Scalars["String"];
  collection_name: Scalars["String"];
  creator_address: Scalars["String"];
  description: Scalars["String"];
  description_mutable: Scalars["Boolean"];
  maximum: Scalars["numeric"];
  maximum_mutable: Scalars["Boolean"];
  metadata_uri: Scalars["String"];
  supply: Scalars["numeric"];
  table_handle: Scalars["String"];
  transaction_timestamp: Scalars["timestamp"];
  transaction_version: Scalars["bigint"];
  uri_mutable: Scalars["Boolean"];
};

/** Boolean expression to filter rows from the table "collection_datas". All fields are combined with a logical 'AND'. */
export type Collection_Datas_Bool_Exp = {
  _and?: InputMaybe<Array<Collection_Datas_Bool_Exp>>;
  _not?: InputMaybe<Collection_Datas_Bool_Exp>;
  _or?: InputMaybe<Array<Collection_Datas_Bool_Exp>>;
  collection_data_id_hash?: InputMaybe<String_Comparison_Exp>;
  collection_name?: InputMaybe<String_Comparison_Exp>;
  creator_address?: InputMaybe<String_Comparison_Exp>;
  description?: InputMaybe<String_Comparison_Exp>;
  description_mutable?: InputMaybe<Boolean_Comparison_Exp>;
  maximum?: InputMaybe<Numeric_Comparison_Exp>;
  maximum_mutable?: InputMaybe<Boolean_Comparison_Exp>;
  metadata_uri?: InputMaybe<String_Comparison_Exp>;
  supply?: InputMaybe<Numeric_Comparison_Exp>;
  table_handle?: InputMaybe<String_Comparison_Exp>;
  transaction_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
  uri_mutable?: InputMaybe<Boolean_Comparison_Exp>;
};

/** Ordering options when selecting data from "collection_datas". */
export type Collection_Datas_Order_By = {
  collection_data_id_hash?: InputMaybe<Order_By>;
  collection_name?: InputMaybe<Order_By>;
  creator_address?: InputMaybe<Order_By>;
  description?: InputMaybe<Order_By>;
  description_mutable?: InputMaybe<Order_By>;
  maximum?: InputMaybe<Order_By>;
  maximum_mutable?: InputMaybe<Order_By>;
  metadata_uri?: InputMaybe<Order_By>;
  supply?: InputMaybe<Order_By>;
  table_handle?: InputMaybe<Order_By>;
  transaction_timestamp?: InputMaybe<Order_By>;
  transaction_version?: InputMaybe<Order_By>;
  uri_mutable?: InputMaybe<Order_By>;
};

/** select columns of table "collection_datas" */
export enum Collection_Datas_Select_Column {
  /** 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" */
export type Collection_Datas_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Collection_Datas_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Collection_Datas_Stream_Cursor_Value_Input = {
  collection_data_id_hash?: InputMaybe<Scalars["String"]>;
  collection_name?: InputMaybe<Scalars["String"]>;
  creator_address?: InputMaybe<Scalars["String"]>;
  description?: InputMaybe<Scalars["String"]>;
  description_mutable?: InputMaybe<Scalars["Boolean"]>;
  maximum?: InputMaybe<Scalars["numeric"]>;
  maximum_mutable?: InputMaybe<Scalars["Boolean"]>;
  metadata_uri?: InputMaybe<Scalars["String"]>;
  supply?: InputMaybe<Scalars["numeric"]>;
  table_handle?: InputMaybe<Scalars["String"]>;
  transaction_timestamp?: InputMaybe<Scalars["timestamp"]>;
  transaction_version?: InputMaybe<Scalars["bigint"]>;
  uri_mutable?: InputMaybe<Scalars["Boolean"]>;
};

/** columns and relationships of "current_ans_lookup" */
export type Current_Ans_Lookup = {
  __typename?: "current_ans_lookup";
  /** An array relationship */
  all_token_ownerships: Array<Current_Token_Ownerships>;
  /** An aggregate relationship */
  all_token_ownerships_aggregate: Current_Token_Ownerships_Aggregate;
  domain: Scalars["String"];
  expiration_timestamp: Scalars["timestamp"];
  last_transaction_version: Scalars["bigint"];
  registered_address?: Maybe<Scalars["String"]>;
  subdomain: Scalars["String"];
};

/** columns and relationships of "current_ans_lookup" */
export type Current_Ans_LookupAll_Token_OwnershipsArgs = {
  distinct_on?: InputMaybe<Array<Current_Token_Ownerships_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Current_Token_Ownerships_Order_By>>;
  where?: InputMaybe<Current_Token_Ownerships_Bool_Exp>;
};

/** columns and relationships of "current_ans_lookup" */
export type Current_Ans_LookupAll_Token_Ownerships_AggregateArgs = {
  distinct_on?: InputMaybe<Array<Current_Token_Ownerships_Select_Column>>;
  limit?: InputMaybe<Scalars["Int"]>;
  offset?: InputMaybe<Scalars["Int"]>;
  order_by?: InputMaybe<Array<Current_Token_Ownerships_Order_By>>;
  where?: InputMaybe<Current_Token_Ownerships_Bool_Exp>;
};

/** order by aggregate values of table "current_ans_lookup" */
export type Current_Ans_Lookup_Aggregate_Order_By = {
  avg?: InputMaybe<Current_Ans_Lookup_Avg_Order_By>;
  count?: InputMaybe<Order_By>;
  max?: InputMaybe<Current_Ans_Lookup_Max_Order_By>;
  min?: InputMaybe<Current_Ans_Lookup_Min_Order_By>;
  stddev?: InputMaybe<Current_Ans_Lookup_Stddev_Order_By>;
  stddev_pop?: InputMaybe<Current_Ans_Lookup_Stddev_Pop_Order_By>;
  stddev_samp?: InputMaybe<Current_Ans_Lookup_Stddev_Samp_Order_By>;
  sum?: InputMaybe<Current_Ans_Lookup_Sum_Order_By>;
  var_pop?: InputMaybe<Current_Ans_Lookup_Var_Pop_Order_By>;
  var_samp?: InputMaybe<Current_Ans_Lookup_Var_Samp_Order_By>;
  variance?: InputMaybe<Current_Ans_Lookup_Variance_Order_By>;
};

/** order by avg() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Avg_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** Boolean expression to filter rows from the table "current_ans_lookup". All fields are combined with a logical 'AND'. */
export type Current_Ans_Lookup_Bool_Exp = {
  _and?: InputMaybe<Array<Current_Ans_Lookup_Bool_Exp>>;
  _not?: InputMaybe<Current_Ans_Lookup_Bool_Exp>;
  _or?: InputMaybe<Array<Current_Ans_Lookup_Bool_Exp>>;
  all_token_ownerships?: InputMaybe<Current_Token_Ownerships_Bool_Exp>;
  domain?: InputMaybe<String_Comparison_Exp>;
  expiration_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  last_transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
  registered_address?: InputMaybe<String_Comparison_Exp>;
  subdomain?: InputMaybe<String_Comparison_Exp>;
};

/** order by max() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Max_Order_By = {
  domain?: InputMaybe<Order_By>;
  expiration_timestamp?: InputMaybe<Order_By>;
  last_transaction_version?: InputMaybe<Order_By>;
  registered_address?: InputMaybe<Order_By>;
  subdomain?: InputMaybe<Order_By>;
};

/** order by min() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Min_Order_By = {
  domain?: InputMaybe<Order_By>;
  expiration_timestamp?: InputMaybe<Order_By>;
  last_transaction_version?: InputMaybe<Order_By>;
  registered_address?: InputMaybe<Order_By>;
  subdomain?: InputMaybe<Order_By>;
};

/** Ordering options when selecting data from "current_ans_lookup". */
export type Current_Ans_Lookup_Order_By = {
  all_token_ownerships_aggregate?: InputMaybe<Current_Token_Ownerships_Aggregate_Order_By>;
  domain?: InputMaybe<Order_By>;
  expiration_timestamp?: InputMaybe<Order_By>;
  last_transaction_version?: InputMaybe<Order_By>;
  registered_address?: InputMaybe<Order_By>;
  subdomain?: InputMaybe<Order_By>;
};

/** select columns of table "current_ans_lookup" */
export enum Current_Ans_Lookup_Select_Column {
  /** column name */
  Domain = "domain",
  /** column name */
  ExpirationTimestamp = "expiration_timestamp",
  /** column name */
  LastTransactionVersion = "last_transaction_version",
  /** column name */
  RegisteredAddress = "registered_address",
  /** column name */
  Subdomain = "subdomain",
}

/** order by stddev() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Stddev_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** order by stddev_pop() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Stddev_Pop_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** order by stddev_samp() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Stddev_Samp_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** Streaming cursor of the table "current_ans_lookup" */
export type Current_Ans_Lookup_Stream_Cursor_Input = {
  /** Stream column input with initial value */
  initial_value: Current_Ans_Lookup_Stream_Cursor_Value_Input;
  /** cursor ordering */
  ordering?: InputMaybe<Cursor_Ordering>;
};

/** Initial value of the column from where the streaming should start */
export type Current_Ans_Lookup_Stream_Cursor_Value_Input = {
  domain?: InputMaybe<Scalars["String"]>;
  expiration_timestamp?: InputMaybe<Scalars["timestamp"]>;
  last_transaction_version?: InputMaybe<Scalars["bigint"]>;
  registered_address?: InputMaybe<Scalars["String"]>;
  subdomain?: InputMaybe<Scalars["String"]>;
};

/** order by sum() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Sum_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** order by var_pop() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Var_Pop_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** order by var_samp() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Var_Samp_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** order by variance() on columns of table "current_ans_lookup" */
export type Current_Ans_Lookup_Variance_Order_By = {
  last_transaction_version?: InputMaybe<Order_By>;
};

/** columns and relationships of "current_coin_balances" */
export type Current_Coin_Balances = {
  __typename?: "current_coin_balances";
  amount: Scalars["numeric"];
  /** An object relationship */
  coin_info?: Maybe<Coin_Infos>;
  coin_type: Scalars["String"];
  coin_type_hash: Scalars["String"];
  last_transaction_timestamp: Scalars["timestamp"];
  last_transaction_version: Scalars["bigint"];
  owner_address: Scalars["String"];
};

/** Boolean expression to filter rows from the table "current_coin_balances". All fields are combined with a logical 'AND'. */
export type Current_Coin_Balances_Bool_Exp = {
  _and?: InputMaybe<Array<Current_Coin_Balances_Bool_Exp>>;
  _not?: InputMaybe<Current_Coin_Balances_Bool_Exp>;
  _or?: InputMaybe<Array<Current_Coin_Balances_Bool_Exp>>;
  amount?: InputMaybe<Numeric_Comparison_Exp>;
  coin_info?: InputMaybe<Coin_Infos_Bool_Exp>;
  coin_type?: InputMaybe<String_Comparison_Exp>;
  coin_type_hash?: InputMaybe<String_Comparison_Exp>;
  last_transaction_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
  last_transaction_version?: InputMaybe<Bigint_Comparison_Exp>;
  owner_address?: InputMaybe<String_Comparison_Exp>;
};

/** Ordering options when selecting data from "current_coin_balances". */
export