schema.graphql

schema {
  query: query_root
  mutation: mutation_root
  subscription: subscription_root
}

"""
whether this query should be cached (Hasura Cloud only)
"""
directive @cached(
  """
  refresh the cache entry
  """
  refresh: Boolean! = false
  """
  measured in seconds
  """
  ttl: Int! = 60
) on QUERY

"""
Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'.
"""
input Boolean_comparison_exp {
  _eq: Boolean
  _gt: Boolean
  _gte: Boolean
  _in: [Boolean!]
  _is_null: Boolean
  _lt: Boolean
  _lte: Boolean
  _neq: Boolean
  _nin: [Boolean!]
}

"""
Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'.
"""
input Int_comparison_exp {
  _eq: Int
  _gt: Int
  _gte: Int
  _in: [Int!]
  _is_null: Boolean
  _lt: Int
  _lte: Int
  _neq: Int
  _nin: [Int!]
}

input PinOrganizationInput {
  description: String
  email: String
  image: String
  name: String
  url: String
}

type PinOutput {
  uri: String
}

input PinPersonInput {
  description: String
  email: String
  identifier: String
  image: String
  name: String
  url: String
}

input PinThingInput {
  description: String
  image: String
  name: String
  url: String
}

"""
Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.
"""
input String_comparison_exp {
  _eq: String
  _gt: String
  _gte: String
  """
  does the column match the given case-insensitive pattern
  """
  _ilike: String
  _in: [String!]
  """
  does the column match the given POSIX regular expression, case insensitive
  """
  _iregex: String
  _is_null: Boolean
  """
  does the column match the given pattern
  """
  _like: String
  _lt: String
  _lte: String
  _neq: String
  """
  does the column NOT match the given case-insensitive pattern
  """
  _nilike: String
  _nin: [String!]
  """
  does the column NOT match the given POSIX regular expression, case insensitive
  """
  _niregex: String
  """
  does the column NOT match the given pattern
  """
  _nlike: String
  """
  does the column NOT match the given POSIX regular expression, case sensitive
  """
  _nregex: String
  """
  does the column NOT match the given SQL regular expression
  """
  _nsimilar: String
  """
  does the column match the given POSIX regular expression, case sensitive
  """
  _regex: String
  """
  does the column match the given SQL regular expression
  """
  _similar: String
}

scalar account_type

"""
Boolean expression to compare columns of type "account_type". All fields are combined with logical 'AND'.
"""
input account_type_comparison_exp {
  _eq: account_type
  _gt: account_type
  _gte: account_type
  _in: [account_type!]
  _is_null: Boolean
  _lt: account_type
  _lte: account_type
  _neq: account_type
  _nin: [account_type!]
}

"""
columns and relationships of "account"
"""
type accounts {
  """
  An object relationship
  """
  atom: atoms
  atom_id: numeric
  """
  An array relationship
  """
  atoms(
    """
    distinct select on columns
    """
    distinct_on: [atoms_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atoms_order_by!]
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): [atoms!]!
  """
  An aggregate relationship
  """
  atoms_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [atoms_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atoms_order_by!]
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): atoms_aggregate!
  """
  An object relationship
  """
  cached_image: cached_images
  """
  An array relationship
  """
  claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  An array relationship
  """
  deposits_received(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): [deposits!]!
  """
  An aggregate relationship
  """
  deposits_received_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): deposits_aggregate!
  """
  An array relationship
  """
  deposits_sent(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): [deposits!]!
  """
  An aggregate relationship
  """
  deposits_sent_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): deposits_aggregate!
  """
  An array relationship
  """
  fee_transfers(
    """
    distinct select on columns
    """
    distinct_on: [fee_transfers_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [fee_transfers_order_by!]
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): [fee_transfers!]!
  """
  An aggregate relationship
  """
  fee_transfers_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [fee_transfers_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [fee_transfers_order_by!]
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): fee_transfers_aggregate!
  id: String!
  image: String
  label: String!
  """
  An array relationship
  """
  positions(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): [positions!]!
  """
  An aggregate relationship
  """
  positions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): positions_aggregate!
  """
  An array relationship
  """
  redemptions_received(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): [redemptions!]!
  """
  An aggregate relationship
  """
  redemptions_received_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): redemptions_aggregate!
  """
  An array relationship
  """
  redemptions_sent(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): [redemptions!]!
  """
  An aggregate relationship
  """
  redemptions_sent_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): redemptions_aggregate!
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  """
  An array relationship
  """
  triples(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  An aggregate relationship
  """
  triples_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): triples_aggregate!
  type: account_type!
}

"""
aggregated selection of "account"
"""
type accounts_aggregate {
  aggregate: accounts_aggregate_fields
  nodes: [accounts!]!
}

input accounts_aggregate_bool_exp {
  count: accounts_aggregate_bool_exp_count
}

input accounts_aggregate_bool_exp_count {
  arguments: [accounts_select_column!]
  distinct: Boolean
  filter: accounts_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "account"
"""
type accounts_aggregate_fields {
  avg: accounts_avg_fields
  count(columns: [accounts_select_column!], distinct: Boolean): Int!
  max: accounts_max_fields
  min: accounts_min_fields
  stddev: accounts_stddev_fields
  stddev_pop: accounts_stddev_pop_fields
  stddev_samp: accounts_stddev_samp_fields
  sum: accounts_sum_fields
  var_pop: accounts_var_pop_fields
  var_samp: accounts_var_samp_fields
  variance: accounts_variance_fields
}

"""
order by aggregate values of table "account"
"""
input accounts_aggregate_order_by {
  avg: accounts_avg_order_by
  count: order_by
  max: accounts_max_order_by
  min: accounts_min_order_by
  stddev: accounts_stddev_order_by
  stddev_pop: accounts_stddev_pop_order_by
  stddev_samp: accounts_stddev_samp_order_by
  sum: accounts_sum_order_by
  var_pop: accounts_var_pop_order_by
  var_samp: accounts_var_samp_order_by
  variance: accounts_variance_order_by
}

"""
aggregate avg on columns
"""
type accounts_avg_fields {
  atom_id: Float
}

"""
order by avg() on columns of table "account"
"""
input accounts_avg_order_by {
  atom_id: order_by
}

"""
Boolean expression to filter rows from the table "account". All fields are combined with a logical 'AND'.
"""
input accounts_bool_exp {
  _and: [accounts_bool_exp!]
  _not: accounts_bool_exp
  _or: [accounts_bool_exp!]
  atom: atoms_bool_exp
  atom_id: numeric_comparison_exp
  atoms: atoms_bool_exp
  atoms_aggregate: atoms_aggregate_bool_exp
  cached_image: cached_images_bool_exp
  claims: claims_bool_exp
  claims_aggregate: claims_aggregate_bool_exp
  deposits_received: deposits_bool_exp
  deposits_received_aggregate: deposits_aggregate_bool_exp
  deposits_sent: deposits_bool_exp
  deposits_sent_aggregate: deposits_aggregate_bool_exp
  fee_transfers: fee_transfers_bool_exp
  fee_transfers_aggregate: fee_transfers_aggregate_bool_exp
  id: String_comparison_exp
  image: String_comparison_exp
  label: String_comparison_exp
  positions: positions_bool_exp
  positions_aggregate: positions_aggregate_bool_exp
  redemptions_received: redemptions_bool_exp
  redemptions_received_aggregate: redemptions_aggregate_bool_exp
  redemptions_sent: redemptions_bool_exp
  redemptions_sent_aggregate: redemptions_aggregate_bool_exp
  signals: signals_bool_exp
  signals_aggregate: signals_aggregate_bool_exp
  triples: triples_bool_exp
  triples_aggregate: triples_aggregate_bool_exp
  type: account_type_comparison_exp
}

"""
aggregate max on columns
"""
type accounts_max_fields {
  atom_id: numeric
  id: String
  image: String
  label: String
  type: account_type
}

"""
order by max() on columns of table "account"
"""
input accounts_max_order_by {
  atom_id: order_by
  id: order_by
  image: order_by
  label: order_by
  type: order_by
}

"""
aggregate min on columns
"""
type accounts_min_fields {
  atom_id: numeric
  id: String
  image: String
  label: String
  type: account_type
}

"""
order by min() on columns of table "account"
"""
input accounts_min_order_by {
  atom_id: order_by
  id: order_by
  image: order_by
  label: order_by
  type: order_by
}

"""
Ordering options when selecting data from "account".
"""
input accounts_order_by {
  atom: atoms_order_by
  atom_id: order_by
  atoms_aggregate: atoms_aggregate_order_by
  cached_image: cached_images_order_by
  claims_aggregate: claims_aggregate_order_by
  deposits_received_aggregate: deposits_aggregate_order_by
  deposits_sent_aggregate: deposits_aggregate_order_by
  fee_transfers_aggregate: fee_transfers_aggregate_order_by
  id: order_by
  image: order_by
  label: order_by
  positions_aggregate: positions_aggregate_order_by
  redemptions_received_aggregate: redemptions_aggregate_order_by
  redemptions_sent_aggregate: redemptions_aggregate_order_by
  signals_aggregate: signals_aggregate_order_by
  triples_aggregate: triples_aggregate_order_by
  type: order_by
}

"""
select columns of table "account"
"""
enum accounts_select_column {
  """
  column name
  """
  atom_id
  """
  column name
  """
  id
  """
  column name
  """
  image
  """
  column name
  """
  label
  """
  column name
  """
  type
}

"""
aggregate stddev on columns
"""
type accounts_stddev_fields {
  atom_id: Float
}

"""
order by stddev() on columns of table "account"
"""
input accounts_stddev_order_by {
  atom_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type accounts_stddev_pop_fields {
  atom_id: Float
}

"""
order by stddev_pop() on columns of table "account"
"""
input accounts_stddev_pop_order_by {
  atom_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type accounts_stddev_samp_fields {
  atom_id: Float
}

"""
order by stddev_samp() on columns of table "account"
"""
input accounts_stddev_samp_order_by {
  atom_id: order_by
}

"""
Streaming cursor of the table "accounts"
"""
input accounts_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: accounts_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input accounts_stream_cursor_value_input {
  atom_id: numeric
  id: String
  image: String
  label: String
  type: account_type
}

"""
aggregate sum on columns
"""
type accounts_sum_fields {
  atom_id: numeric
}

"""
order by sum() on columns of table "account"
"""
input accounts_sum_order_by {
  atom_id: order_by
}

input accounts_that_claim_about_account_args {
  address: String
  predicate: numeric
  subject: numeric
}

"""
aggregate var_pop on columns
"""
type accounts_var_pop_fields {
  atom_id: Float
}

"""
order by var_pop() on columns of table "account"
"""
input accounts_var_pop_order_by {
  atom_id: order_by
}

"""
aggregate var_samp on columns
"""
type accounts_var_samp_fields {
  atom_id: Float
}

"""
order by var_samp() on columns of table "account"
"""
input accounts_var_samp_order_by {
  atom_id: order_by
}

"""
aggregate variance on columns
"""
type accounts_variance_fields {
  atom_id: Float
}

"""
order by variance() on columns of table "account"
"""
input accounts_variance_order_by {
  atom_id: order_by
}

scalar atom_type

"""
Boolean expression to compare columns of type "atom_type". All fields are combined with logical 'AND'.
"""
input atom_type_comparison_exp {
  _eq: atom_type
  _gt: atom_type
  _gte: atom_type
  _in: [atom_type!]
  _is_null: Boolean
  _lt: atom_type
  _lte: atom_type
  _neq: atom_type
  _nin: [atom_type!]
}

"""
columns and relationships of "atom_value"
"""
type atom_values {
  """
  An object relationship
  """
  account: accounts
  account_id: String
  """
  An object relationship
  """
  atom: atoms
  """
  An object relationship
  """
  book: books
  book_id: numeric
  id: numeric!
  """
  An object relationship
  """
  organization: organizations
  organization_id: numeric
  """
  An object relationship
  """
  person: persons
  person_id: numeric
  """
  An object relationship
  """
  thing: things
  thing_id: numeric
}

"""
aggregated selection of "atom_value"
"""
type atom_values_aggregate {
  aggregate: atom_values_aggregate_fields
  nodes: [atom_values!]!
}

"""
aggregate fields of "atom_value"
"""
type atom_values_aggregate_fields {
  avg: atom_values_avg_fields
  count(columns: [atom_values_select_column!], distinct: Boolean): Int!
  max: atom_values_max_fields
  min: atom_values_min_fields
  stddev: atom_values_stddev_fields
  stddev_pop: atom_values_stddev_pop_fields
  stddev_samp: atom_values_stddev_samp_fields
  sum: atom_values_sum_fields
  var_pop: atom_values_var_pop_fields
  var_samp: atom_values_var_samp_fields
  variance: atom_values_variance_fields
}

"""
aggregate avg on columns
"""
type atom_values_avg_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
Boolean expression to filter rows from the table "atom_value". All fields are combined with a logical 'AND'.
"""
input atom_values_bool_exp {
  _and: [atom_values_bool_exp!]
  _not: atom_values_bool_exp
  _or: [atom_values_bool_exp!]
  account: accounts_bool_exp
  account_id: String_comparison_exp
  atom: atoms_bool_exp
  book: books_bool_exp
  book_id: numeric_comparison_exp
  id: numeric_comparison_exp
  organization: organizations_bool_exp
  organization_id: numeric_comparison_exp
  person: persons_bool_exp
  person_id: numeric_comparison_exp
  thing: things_bool_exp
  thing_id: numeric_comparison_exp
}

"""
aggregate max on columns
"""
type atom_values_max_fields {
  account_id: String
  book_id: numeric
  id: numeric
  organization_id: numeric
  person_id: numeric
  thing_id: numeric
}

"""
aggregate min on columns
"""
type atom_values_min_fields {
  account_id: String
  book_id: numeric
  id: numeric
  organization_id: numeric
  person_id: numeric
  thing_id: numeric
}

"""
Ordering options when selecting data from "atom_value".
"""
input atom_values_order_by {
  account: accounts_order_by
  account_id: order_by
  atom: atoms_order_by
  book: books_order_by
  book_id: order_by
  id: order_by
  organization: organizations_order_by
  organization_id: order_by
  person: persons_order_by
  person_id: order_by
  thing: things_order_by
  thing_id: order_by
}

"""
select columns of table "atom_value"
"""
enum atom_values_select_column {
  """
  column name
  """
  account_id
  """
  column name
  """
  book_id
  """
  column name
  """
  id
  """
  column name
  """
  organization_id
  """
  column name
  """
  person_id
  """
  column name
  """
  thing_id
}

"""
aggregate stddev on columns
"""
type atom_values_stddev_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
aggregate stddev_pop on columns
"""
type atom_values_stddev_pop_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
aggregate stddev_samp on columns
"""
type atom_values_stddev_samp_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
Streaming cursor of the table "atom_values"
"""
input atom_values_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: atom_values_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input atom_values_stream_cursor_value_input {
  account_id: String
  book_id: numeric
  id: numeric
  organization_id: numeric
  person_id: numeric
  thing_id: numeric
}

"""
aggregate sum on columns
"""
type atom_values_sum_fields {
  book_id: numeric
  id: numeric
  organization_id: numeric
  person_id: numeric
  thing_id: numeric
}

"""
aggregate var_pop on columns
"""
type atom_values_var_pop_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
aggregate var_samp on columns
"""
type atom_values_var_samp_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
aggregate variance on columns
"""
type atom_values_variance_fields {
  book_id: Float
  id: Float
  organization_id: Float
  person_id: Float
  thing_id: Float
}

"""
columns and relationships of "atom"
"""
type atoms {
  """
  An array relationship
  """
  accounts(
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  An aggregate relationship
  """
  accounts_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  An array relationship
  """
  as_object_claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  as_object_claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  An array relationship
  """
  as_object_triples(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  An aggregate relationship
  """
  as_object_triples_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): triples_aggregate!
  """
  An array relationship
  """
  as_predicate_claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  as_predicate_claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  An array relationship
  """
  as_predicate_triples(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  An aggregate relationship
  """
  as_predicate_triples_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): triples_aggregate!
  """
  An array relationship
  """
  as_subject_claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  as_subject_claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  An array relationship
  """
  as_subject_triples(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  An aggregate relationship
  """
  as_subject_triples_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): triples_aggregate!
  block_number: numeric!
  block_timestamp: bigint!
  """
  An object relationship
  """
  cached_image: cached_images
  """
  An object relationship
  """
  controler: accounts
  """
  An object relationship
  """
  creator: accounts
  creator_id: String!
  data: String
  emoji: String
  id: numeric!
  image: String
  label: String
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  transaction_hash: bytea!
  type: atom_type!
  """
  An object relationship
  """
  value: atom_values
  value_id: numeric
  """
  An object relationship
  """
  vault: vaults
  vault_id: numeric!
  wallet_id: String!
}

"""
aggregated selection of "atom"
"""
type atoms_aggregate {
  aggregate: atoms_aggregate_fields
  nodes: [atoms!]!
}

input atoms_aggregate_bool_exp {
  count: atoms_aggregate_bool_exp_count
}

input atoms_aggregate_bool_exp_count {
  arguments: [atoms_select_column!]
  distinct: Boolean
  filter: atoms_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "atom"
"""
type atoms_aggregate_fields {
  avg: atoms_avg_fields
  count(columns: [atoms_select_column!], distinct: Boolean): Int!
  max: atoms_max_fields
  min: atoms_min_fields
  stddev: atoms_stddev_fields
  stddev_pop: atoms_stddev_pop_fields
  stddev_samp: atoms_stddev_samp_fields
  sum: atoms_sum_fields
  var_pop: atoms_var_pop_fields
  var_samp: atoms_var_samp_fields
  variance: atoms_variance_fields
}

"""
order by aggregate values of table "atom"
"""
input atoms_aggregate_order_by {
  avg: atoms_avg_order_by
  count: order_by
  max: atoms_max_order_by
  min: atoms_min_order_by
  stddev: atoms_stddev_order_by
  stddev_pop: atoms_stddev_pop_order_by
  stddev_samp: atoms_stddev_samp_order_by
  sum: atoms_sum_order_by
  var_pop: atoms_var_pop_order_by
  var_samp: atoms_var_samp_order_by
  variance: atoms_variance_order_by
}

"""
aggregate avg on columns
"""
type atoms_avg_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by avg() on columns of table "atom"
"""
input atoms_avg_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
Boolean expression to filter rows from the table "atom". All fields are combined with a logical 'AND'.
"""
input atoms_bool_exp {
  _and: [atoms_bool_exp!]
  _not: atoms_bool_exp
  _or: [atoms_bool_exp!]
  accounts: accounts_bool_exp
  accounts_aggregate: accounts_aggregate_bool_exp
  as_object_claims: claims_bool_exp
  as_object_claims_aggregate: claims_aggregate_bool_exp
  as_object_triples: triples_bool_exp
  as_object_triples_aggregate: triples_aggregate_bool_exp
  as_predicate_claims: claims_bool_exp
  as_predicate_claims_aggregate: claims_aggregate_bool_exp
  as_predicate_triples: triples_bool_exp
  as_predicate_triples_aggregate: triples_aggregate_bool_exp
  as_subject_claims: claims_bool_exp
  as_subject_claims_aggregate: claims_aggregate_bool_exp
  as_subject_triples: triples_bool_exp
  as_subject_triples_aggregate: triples_aggregate_bool_exp
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  cached_image: cached_images_bool_exp
  controler: accounts_bool_exp
  creator: accounts_bool_exp
  creator_id: String_comparison_exp
  data: String_comparison_exp
  emoji: String_comparison_exp
  id: numeric_comparison_exp
  image: String_comparison_exp
  label: String_comparison_exp
  signals: signals_bool_exp
  signals_aggregate: signals_aggregate_bool_exp
  transaction_hash: bytea_comparison_exp
  type: atom_type_comparison_exp
  value: atom_values_bool_exp
  value_id: numeric_comparison_exp
  vault: vaults_bool_exp
  vault_id: numeric_comparison_exp
  wallet_id: String_comparison_exp
}

"""
aggregate max on columns
"""
type atoms_max_fields {
  block_number: numeric
  block_timestamp: bigint
  creator_id: String
  data: String
  emoji: String
  id: numeric
  image: String
  label: String
  type: atom_type
  value_id: numeric
  vault_id: numeric
  wallet_id: String
}

"""
order by max() on columns of table "atom"
"""
input atoms_max_order_by {
  block_number: order_by
  block_timestamp: order_by
  creator_id: order_by
  data: order_by
  emoji: order_by
  id: order_by
  image: order_by
  label: order_by
  type: order_by
  value_id: order_by
  vault_id: order_by
  wallet_id: order_by
}

"""
aggregate min on columns
"""
type atoms_min_fields {
  block_number: numeric
  block_timestamp: bigint
  creator_id: String
  data: String
  emoji: String
  id: numeric
  image: String
  label: String
  type: atom_type
  value_id: numeric
  vault_id: numeric
  wallet_id: String
}

"""
order by min() on columns of table "atom"
"""
input atoms_min_order_by {
  block_number: order_by
  block_timestamp: order_by
  creator_id: order_by
  data: order_by
  emoji: order_by
  id: order_by
  image: order_by
  label: order_by
  type: order_by
  value_id: order_by
  vault_id: order_by
  wallet_id: order_by
}

"""
Ordering options when selecting data from "atom".
"""
input atoms_order_by {
  accounts_aggregate: accounts_aggregate_order_by
  as_object_claims_aggregate: claims_aggregate_order_by
  as_object_triples_aggregate: triples_aggregate_order_by
  as_predicate_claims_aggregate: claims_aggregate_order_by
  as_predicate_triples_aggregate: triples_aggregate_order_by
  as_subject_claims_aggregate: claims_aggregate_order_by
  as_subject_triples_aggregate: triples_aggregate_order_by
  block_number: order_by
  block_timestamp: order_by
  cached_image: cached_images_order_by
  controler: accounts_order_by
  creator: accounts_order_by
  creator_id: order_by
  data: order_by
  emoji: order_by
  id: order_by
  image: order_by
  label: order_by
  signals_aggregate: signals_aggregate_order_by
  transaction_hash: order_by
  type: order_by
  value: atom_values_order_by
  value_id: order_by
  vault: vaults_order_by
  vault_id: order_by
  wallet_id: order_by
}

"""
select columns of table "atom"
"""
enum atoms_select_column {
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  creator_id
  """
  column name
  """
  data
  """
  column name
  """
  emoji
  """
  column name
  """
  id
  """
  column name
  """
  image
  """
  column name
  """
  label
  """
  column name
  """
  transaction_hash
  """
  column name
  """
  type
  """
  column name
  """
  value_id
  """
  column name
  """
  vault_id
  """
  column name
  """
  wallet_id
}

"""
aggregate stddev on columns
"""
type atoms_stddev_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by stddev() on columns of table "atom"
"""
input atoms_stddev_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type atoms_stddev_pop_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by stddev_pop() on columns of table "atom"
"""
input atoms_stddev_pop_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type atoms_stddev_samp_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by stddev_samp() on columns of table "atom"
"""
input atoms_stddev_samp_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
Streaming cursor of the table "atoms"
"""
input atoms_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: atoms_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input atoms_stream_cursor_value_input {
  block_number: numeric
  block_timestamp: bigint
  creator_id: String
  data: String
  emoji: String
  id: numeric
  image: String
  label: String
  transaction_hash: bytea
  type: atom_type
  value_id: numeric
  vault_id: numeric
  wallet_id: String
}

"""
aggregate sum on columns
"""
type atoms_sum_fields {
  block_number: numeric
  block_timestamp: bigint
  id: numeric
  value_id: numeric
  vault_id: numeric
}

"""
order by sum() on columns of table "atom"
"""
input atoms_sum_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
aggregate var_pop on columns
"""
type atoms_var_pop_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by var_pop() on columns of table "atom"
"""
input atoms_var_pop_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
aggregate var_samp on columns
"""
type atoms_var_samp_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by var_samp() on columns of table "atom"
"""
input atoms_var_samp_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

"""
aggregate variance on columns
"""
type atoms_variance_fields {
  block_number: Float
  block_timestamp: Float
  id: Float
  value_id: Float
  vault_id: Float
}

"""
order by variance() on columns of table "atom"
"""
input atoms_variance_order_by {
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  value_id: order_by
  vault_id: order_by
}

scalar bigint

"""
Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'.
"""
input bigint_comparison_exp {
  _eq: bigint
  _gt: bigint
  _gte: bigint
  _in: [bigint!]
  _is_null: Boolean
  _lt: bigint
  _lte: bigint
  _neq: bigint
  _nin: [bigint!]
}

"""
columns and relationships of "book"
"""
type books {
  """
  An object relationship
  """
  atom: atoms
  description: String
  genre: String
  id: numeric!
  name: String
  url: String
}

"""
aggregated selection of "book"
"""
type books_aggregate {
  aggregate: books_aggregate_fields
  nodes: [books!]!
}

"""
aggregate fields of "book"
"""
type books_aggregate_fields {
  avg: books_avg_fields
  count(columns: [books_select_column!], distinct: Boolean): Int!
  max: books_max_fields
  min: books_min_fields
  stddev: books_stddev_fields
  stddev_pop: books_stddev_pop_fields
  stddev_samp: books_stddev_samp_fields
  sum: books_sum_fields
  var_pop: books_var_pop_fields
  var_samp: books_var_samp_fields
  variance: books_variance_fields
}

"""
aggregate avg on columns
"""
type books_avg_fields {
  id: Float
}

"""
Boolean expression to filter rows from the table "book". All fields are combined with a logical 'AND'.
"""
input books_bool_exp {
  _and: [books_bool_exp!]
  _not: books_bool_exp
  _or: [books_bool_exp!]
  atom: atoms_bool_exp
  description: String_comparison_exp
  genre: String_comparison_exp
  id: numeric_comparison_exp
  name: String_comparison_exp
  url: String_comparison_exp
}

"""
aggregate max on columns
"""
type books_max_fields {
  description: String
  genre: String
  id: numeric
  name: String
  url: String
}

"""
aggregate min on columns
"""
type books_min_fields {
  description: String
  genre: String
  id: numeric
  name: String
  url: String
}

"""
Ordering options when selecting data from "book".
"""
input books_order_by {
  atom: atoms_order_by
  description: order_by
  genre: order_by
  id: order_by
  name: order_by
  url: order_by
}

"""
select columns of table "book"
"""
enum books_select_column {
  """
  column name
  """
  description
  """
  column name
  """
  genre
  """
  column name
  """
  id
  """
  column name
  """
  name
  """
  column name
  """
  url
}

"""
aggregate stddev on columns
"""
type books_stddev_fields {
  id: Float
}

"""
aggregate stddev_pop on columns
"""
type books_stddev_pop_fields {
  id: Float
}

"""
aggregate stddev_samp on columns
"""
type books_stddev_samp_fields {
  id: Float
}

"""
Streaming cursor of the table "books"
"""
input books_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: books_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input books_stream_cursor_value_input {
  description: String
  genre: String
  id: numeric
  name: String
  url: String
}

"""
aggregate sum on columns
"""
type books_sum_fields {
  id: numeric
}

"""
aggregate var_pop on columns
"""
type books_var_pop_fields {
  id: Float
}

"""
aggregate var_samp on columns
"""
type books_var_samp_fields {
  id: Float
}

"""
aggregate variance on columns
"""
type books_variance_fields {
  id: Float
}

scalar bytea

"""
Boolean expression to compare columns of type "bytea". All fields are combined with logical 'AND'.
"""
input bytea_comparison_exp {
  _eq: bytea
  _gt: bytea
  _gte: bytea
  _in: [bytea!]
  _is_null: Boolean
  _lt: bytea
  _lte: bytea
  _neq: bytea
  _nin: [bytea!]
}

"""
columns and relationships of "cached_image"
"""
type cached_images {
  created_at: timestamptz!
  model: String
  original_url: String!
  safe: Boolean!
  score(
    """
    JSON select path
    """
    path: String
  ): jsonb
  url: String!
}

"""
Boolean expression to filter rows from the table "cached_image". All fields are combined with a logical 'AND'.
"""
input cached_images_bool_exp {
  _and: [cached_images_bool_exp!]
  _not: cached_images_bool_exp
  _or: [cached_images_bool_exp!]
  created_at: timestamptz_comparison_exp
  model: String_comparison_exp
  original_url: String_comparison_exp
  safe: Boolean_comparison_exp
  score: jsonb_comparison_exp
  url: String_comparison_exp
}

"""
Ordering options when selecting data from "cached_image".
"""
input cached_images_order_by {
  created_at: order_by
  model: order_by
  original_url: order_by
  safe: order_by
  score: order_by
  url: order_by
}

"""
select columns of table "cached_image"
"""
enum cached_images_select_column {
  """
  column name
  """
  created_at
  """
  column name
  """
  model
  """
  column name
  """
  original_url
  """
  column name
  """
  safe
  """
  column name
  """
  score
  """
  column name
  """
  url
}

"""
Streaming cursor of the table "cached_images"
"""
input cached_images_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: cached_images_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input cached_images_stream_cursor_value_input {
  created_at: timestamptz
  model: String
  original_url: String
  safe: Boolean
  score: jsonb
  url: String
}

"""
columns and relationships of "chainlink_price"
"""
type chainlink_prices {
  id: numeric!
  usd: float8
}

"""
Boolean expression to filter rows from the table "chainlink_price". All fields are combined with a logical 'AND'.
"""
input chainlink_prices_bool_exp {
  _and: [chainlink_prices_bool_exp!]
  _not: chainlink_prices_bool_exp
  _or: [chainlink_prices_bool_exp!]
  id: numeric_comparison_exp
  usd: float8_comparison_exp
}

"""
Ordering options when selecting data from "chainlink_price".
"""
input chainlink_prices_order_by {
  id: order_by
  usd: order_by
}

"""
select columns of table "chainlink_price"
"""
enum chainlink_prices_select_column {
  """
  column name
  """
  id
  """
  column name
  """
  usd
}

"""
Streaming cursor of the table "chainlink_prices"
"""
input chainlink_prices_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: chainlink_prices_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input chainlink_prices_stream_cursor_value_input {
  id: numeric
  usd: float8
}

"""
columns and relationships of "claim"
"""
type claims {
  """
  An object relationship
  """
  account: accounts
  account_id: String!
  counter_shares: numeric!
  """
  An object relationship
  """
  counter_vault: vaults!
  counter_vault_id: numeric!
  id: String!
  """
  An object relationship
  """
  object: atoms!
  object_id: numeric!
  """
  An object relationship
  """
  predicate: atoms!
  predicate_id: numeric!
  shares: numeric!
  """
  An object relationship
  """
  subject: atoms!
  subject_id: numeric!
  """
  An object relationship
  """
  triple: triples!
  triple_id: numeric!
  """
  An object relationship
  """
  vault: vaults!
  vault_id: numeric!
}

"""
aggregated selection of "claim"
"""
type claims_aggregate {
  aggregate: claims_aggregate_fields
  nodes: [claims!]!
}

input claims_aggregate_bool_exp {
  count: claims_aggregate_bool_exp_count
}

input claims_aggregate_bool_exp_count {
  arguments: [claims_select_column!]
  distinct: Boolean
  filter: claims_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "claim"
"""
type claims_aggregate_fields {
  avg: claims_avg_fields
  count(columns: [claims_select_column!], distinct: Boolean): Int!
  max: claims_max_fields
  min: claims_min_fields
  stddev: claims_stddev_fields
  stddev_pop: claims_stddev_pop_fields
  stddev_samp: claims_stddev_samp_fields
  sum: claims_sum_fields
  var_pop: claims_var_pop_fields
  var_samp: claims_var_samp_fields
  variance: claims_variance_fields
}

"""
order by aggregate values of table "claim"
"""
input claims_aggregate_order_by {
  avg: claims_avg_order_by
  count: order_by
  max: claims_max_order_by
  min: claims_min_order_by
  stddev: claims_stddev_order_by
  stddev_pop: claims_stddev_pop_order_by
  stddev_samp: claims_stddev_samp_order_by
  sum: claims_sum_order_by
  var_pop: claims_var_pop_order_by
  var_samp: claims_var_samp_order_by
  variance: claims_variance_order_by
}

"""
aggregate avg on columns
"""
type claims_avg_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by avg() on columns of table "claim"
"""
input claims_avg_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
Boolean expression to filter rows from the table "claim". All fields are combined with a logical 'AND'.
"""
input claims_bool_exp {
  _and: [claims_bool_exp!]
  _not: claims_bool_exp
  _or: [claims_bool_exp!]
  account: accounts_bool_exp
  account_id: String_comparison_exp
  counter_shares: numeric_comparison_exp
  counter_vault: vaults_bool_exp
  counter_vault_id: numeric_comparison_exp
  id: String_comparison_exp
  object: atoms_bool_exp
  object_id: numeric_comparison_exp
  predicate: atoms_bool_exp
  predicate_id: numeric_comparison_exp
  shares: numeric_comparison_exp
  subject: atoms_bool_exp
  subject_id: numeric_comparison_exp
  triple: triples_bool_exp
  triple_id: numeric_comparison_exp
  vault: vaults_bool_exp
  vault_id: numeric_comparison_exp
}

input claims_from_following_args {
  address: String
}

"""
aggregate max on columns
"""
type claims_max_fields {
  account_id: String
  counter_shares: numeric
  counter_vault_id: numeric
  id: String
  object_id: numeric
  predicate_id: numeric
  shares: numeric
  subject_id: numeric
  triple_id: numeric
  vault_id: numeric
}

"""
order by max() on columns of table "claim"
"""
input claims_max_order_by {
  account_id: order_by
  counter_shares: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
aggregate min on columns
"""
type claims_min_fields {
  account_id: String
  counter_shares: numeric
  counter_vault_id: numeric
  id: String
  object_id: numeric
  predicate_id: numeric
  shares: numeric
  subject_id: numeric
  triple_id: numeric
  vault_id: numeric
}

"""
order by min() on columns of table "claim"
"""
input claims_min_order_by {
  account_id: order_by
  counter_shares: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
Ordering options when selecting data from "claim".
"""
input claims_order_by {
  account: accounts_order_by
  account_id: order_by
  counter_shares: order_by
  counter_vault: vaults_order_by
  counter_vault_id: order_by
  id: order_by
  object: atoms_order_by
  object_id: order_by
  predicate: atoms_order_by
  predicate_id: order_by
  shares: order_by
  subject: atoms_order_by
  subject_id: order_by
  triple: triples_order_by
  triple_id: order_by
  vault: vaults_order_by
  vault_id: order_by
}

"""
select columns of table "claim"
"""
enum claims_select_column {
  """
  column name
  """
  account_id
  """
  column name
  """
  counter_shares
  """
  column name
  """
  counter_vault_id
  """
  column name
  """
  id
  """
  column name
  """
  object_id
  """
  column name
  """
  predicate_id
  """
  column name
  """
  shares
  """
  column name
  """
  subject_id
  """
  column name
  """
  triple_id
  """
  column name
  """
  vault_id
}

"""
aggregate stddev on columns
"""
type claims_stddev_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by stddev() on columns of table "claim"
"""
input claims_stddev_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type claims_stddev_pop_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by stddev_pop() on columns of table "claim"
"""
input claims_stddev_pop_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type claims_stddev_samp_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by stddev_samp() on columns of table "claim"
"""
input claims_stddev_samp_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
Streaming cursor of the table "claims"
"""
input claims_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: claims_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input claims_stream_cursor_value_input {
  account_id: String
  counter_shares: numeric
  counter_vault_id: numeric
  id: String
  object_id: numeric
  predicate_id: numeric
  shares: numeric
  subject_id: numeric
  triple_id: numeric
  vault_id: numeric
}

"""
aggregate sum on columns
"""
type claims_sum_fields {
  counter_shares: numeric
  counter_vault_id: numeric
  object_id: numeric
  predicate_id: numeric
  shares: numeric
  subject_id: numeric
  triple_id: numeric
  vault_id: numeric
}

"""
order by sum() on columns of table "claim"
"""
input claims_sum_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
aggregate var_pop on columns
"""
type claims_var_pop_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by var_pop() on columns of table "claim"
"""
input claims_var_pop_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
aggregate var_samp on columns
"""
type claims_var_samp_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by var_samp() on columns of table "claim"
"""
input claims_var_samp_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
aggregate variance on columns
"""
type claims_variance_fields {
  counter_shares: Float
  counter_vault_id: Float
  object_id: Float
  predicate_id: Float
  shares: Float
  subject_id: Float
  triple_id: Float
  vault_id: Float
}

"""
order by variance() on columns of table "claim"
"""
input claims_variance_order_by {
  counter_shares: order_by
  counter_vault_id: order_by
  object_id: order_by
  predicate_id: order_by
  shares: order_by
  subject_id: order_by
  triple_id: order_by
  vault_id: order_by
}

"""
ordering argument of a cursor
"""
enum cursor_ordering {
  """
  ascending ordering of the cursor
  """
  ASC
  """
  descending ordering of the cursor
  """
  DESC
}

"""
columns and relationships of "deposit"
"""
type deposits {
  block_number: numeric!
  block_timestamp: bigint!
  entry_fee: numeric!
  """
  An array relationship
  """
  events(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): [events!]!
  """
  An aggregate relationship
  """
  events_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): events_aggregate!
  id: String!
  is_atom_wallet: Boolean!
  is_triple: Boolean!
  """
  An object relationship
  """
  receiver: accounts!
  receiver_id: String!
  receiver_total_shares_in_vault: numeric!
  """
  An object relationship
  """
  sender: accounts
  sender_assets_after_total_fees: numeric!
  sender_id: String!
  shares_for_receiver: numeric!
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  transaction_hash: bytea!
  """
  An object relationship
  """
  vault: vaults!
  vault_id: numeric!
}

"""
aggregated selection of "deposit"
"""
type deposits_aggregate {
  aggregate: deposits_aggregate_fields
  nodes: [deposits!]!
}

input deposits_aggregate_bool_exp {
  bool_and: deposits_aggregate_bool_exp_bool_and
  bool_or: deposits_aggregate_bool_exp_bool_or
  count: deposits_aggregate_bool_exp_count
}

input deposits_aggregate_bool_exp_bool_and {
  arguments: deposits_select_column_deposits_aggregate_bool_exp_bool_and_arguments_columns!
  distinct: Boolean
  filter: deposits_bool_exp
  predicate: Boolean_comparison_exp!
}

input deposits_aggregate_bool_exp_bool_or {
  arguments: deposits_select_column_deposits_aggregate_bool_exp_bool_or_arguments_columns!
  distinct: Boolean
  filter: deposits_bool_exp
  predicate: Boolean_comparison_exp!
}

input deposits_aggregate_bool_exp_count {
  arguments: [deposits_select_column!]
  distinct: Boolean
  filter: deposits_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "deposit"
"""
type deposits_aggregate_fields {
  avg: deposits_avg_fields
  count(columns: [deposits_select_column!], distinct: Boolean): Int!
  max: deposits_max_fields
  min: deposits_min_fields
  stddev: deposits_stddev_fields
  stddev_pop: deposits_stddev_pop_fields
  stddev_samp: deposits_stddev_samp_fields
  sum: deposits_sum_fields
  var_pop: deposits_var_pop_fields
  var_samp: deposits_var_samp_fields
  variance: deposits_variance_fields
}

"""
order by aggregate values of table "deposit"
"""
input deposits_aggregate_order_by {
  avg: deposits_avg_order_by
  count: order_by
  max: deposits_max_order_by
  min: deposits_min_order_by
  stddev: deposits_stddev_order_by
  stddev_pop: deposits_stddev_pop_order_by
  stddev_samp: deposits_stddev_samp_order_by
  sum: deposits_sum_order_by
  var_pop: deposits_var_pop_order_by
  var_samp: deposits_var_samp_order_by
  variance: deposits_variance_order_by
}

"""
aggregate avg on columns
"""
type deposits_avg_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by avg() on columns of table "deposit"
"""
input deposits_avg_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
Boolean expression to filter rows from the table "deposit". All fields are combined with a logical 'AND'.
"""
input deposits_bool_exp {
  _and: [deposits_bool_exp!]
  _not: deposits_bool_exp
  _or: [deposits_bool_exp!]
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  entry_fee: numeric_comparison_exp
  events: events_bool_exp
  events_aggregate: events_aggregate_bool_exp
  id: String_comparison_exp
  is_atom_wallet: Boolean_comparison_exp
  is_triple: Boolean_comparison_exp
  receiver: accounts_bool_exp
  receiver_id: String_comparison_exp
  receiver_total_shares_in_vault: numeric_comparison_exp
  sender: accounts_bool_exp
  sender_assets_after_total_fees: numeric_comparison_exp
  sender_id: String_comparison_exp
  shares_for_receiver: numeric_comparison_exp
  signals: signals_bool_exp
  signals_aggregate: signals_aggregate_bool_exp
  transaction_hash: bytea_comparison_exp
  vault: vaults_bool_exp
  vault_id: numeric_comparison_exp
}

"""
aggregate max on columns
"""
type deposits_max_fields {
  block_number: numeric
  block_timestamp: bigint
  entry_fee: numeric
  id: String
  receiver_id: String
  receiver_total_shares_in_vault: numeric
  sender_assets_after_total_fees: numeric
  sender_id: String
  shares_for_receiver: numeric
  vault_id: numeric
}

"""
order by max() on columns of table "deposit"
"""
input deposits_max_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  id: order_by
  receiver_id: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  sender_id: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
aggregate min on columns
"""
type deposits_min_fields {
  block_number: numeric
  block_timestamp: bigint
  entry_fee: numeric
  id: String
  receiver_id: String
  receiver_total_shares_in_vault: numeric
  sender_assets_after_total_fees: numeric
  sender_id: String
  shares_for_receiver: numeric
  vault_id: numeric
}

"""
order by min() on columns of table "deposit"
"""
input deposits_min_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  id: order_by
  receiver_id: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  sender_id: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
Ordering options when selecting data from "deposit".
"""
input deposits_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  events_aggregate: events_aggregate_order_by
  id: order_by
  is_atom_wallet: order_by
  is_triple: order_by
  receiver: accounts_order_by
  receiver_id: order_by
  receiver_total_shares_in_vault: order_by
  sender: accounts_order_by
  sender_assets_after_total_fees: order_by
  sender_id: order_by
  shares_for_receiver: order_by
  signals_aggregate: signals_aggregate_order_by
  transaction_hash: order_by
  vault: vaults_order_by
  vault_id: order_by
}

"""
select columns of table "deposit"
"""
enum deposits_select_column {
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  entry_fee
  """
  column name
  """
  id
  """
  column name
  """
  is_atom_wallet
  """
  column name
  """
  is_triple
  """
  column name
  """
  receiver_id
  """
  column name
  """
  receiver_total_shares_in_vault
  """
  column name
  """
  sender_assets_after_total_fees
  """
  column name
  """
  sender_id
  """
  column name
  """
  shares_for_receiver
  """
  column name
  """
  transaction_hash
  """
  column name
  """
  vault_id
}

"""
select "deposits_aggregate_bool_exp_bool_and_arguments_columns" columns of table "deposit"
"""
enum deposits_select_column_deposits_aggregate_bool_exp_bool_and_arguments_columns {
  """
  column name
  """
  is_atom_wallet
  """
  column name
  """
  is_triple
}

"""
select "deposits_aggregate_bool_exp_bool_or_arguments_columns" columns of table "deposit"
"""
enum deposits_select_column_deposits_aggregate_bool_exp_bool_or_arguments_columns {
  """
  column name
  """
  is_atom_wallet
  """
  column name
  """
  is_triple
}

"""
aggregate stddev on columns
"""
type deposits_stddev_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by stddev() on columns of table "deposit"
"""
input deposits_stddev_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type deposits_stddev_pop_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by stddev_pop() on columns of table "deposit"
"""
input deposits_stddev_pop_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type deposits_stddev_samp_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by stddev_samp() on columns of table "deposit"
"""
input deposits_stddev_samp_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
Streaming cursor of the table "deposits"
"""
input deposits_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: deposits_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input deposits_stream_cursor_value_input {
  block_number: numeric
  block_timestamp: bigint
  entry_fee: numeric
  id: String
  is_atom_wallet: Boolean
  is_triple: Boolean
  receiver_id: String
  receiver_total_shares_in_vault: numeric
  sender_assets_after_total_fees: numeric
  sender_id: String
  shares_for_receiver: numeric
  transaction_hash: bytea
  vault_id: numeric
}

"""
aggregate sum on columns
"""
type deposits_sum_fields {
  block_number: numeric
  block_timestamp: bigint
  entry_fee: numeric
  receiver_total_shares_in_vault: numeric
  sender_assets_after_total_fees: numeric
  shares_for_receiver: numeric
  vault_id: numeric
}

"""
order by sum() on columns of table "deposit"
"""
input deposits_sum_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
aggregate var_pop on columns
"""
type deposits_var_pop_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by var_pop() on columns of table "deposit"
"""
input deposits_var_pop_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
aggregate var_samp on columns
"""
type deposits_var_samp_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by var_samp() on columns of table "deposit"
"""
input deposits_var_samp_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

"""
aggregate variance on columns
"""
type deposits_variance_fields {
  block_number: Float
  block_timestamp: Float
  entry_fee: Float
  receiver_total_shares_in_vault: Float
  sender_assets_after_total_fees: Float
  shares_for_receiver: Float
  vault_id: Float
}

"""
order by variance() on columns of table "deposit"
"""
input deposits_variance_order_by {
  block_number: order_by
  block_timestamp: order_by
  entry_fee: order_by
  receiver_total_shares_in_vault: order_by
  sender_assets_after_total_fees: order_by
  shares_for_receiver: order_by
  vault_id: order_by
}

scalar event_type

"""
Boolean expression to compare columns of type "event_type". All fields are combined with logical 'AND'.
"""
input event_type_comparison_exp {
  _eq: event_type
  _gt: event_type
  _gte: event_type
  _in: [event_type!]
  _is_null: Boolean
  _lt: event_type
  _lte: event_type
  _neq: event_type
  _nin: [event_type!]
}

"""
columns and relationships of "event"
"""
type events {
  """
  An object relationship
  """
  atom: atoms
  atom_id: numeric
  block_number: numeric!
  block_timestamp: bigint!
  """
  An object relationship
  """
  deposit: deposits
  deposit_id: String
  """
  An object relationship
  """
  fee_transfer: fee_transfers
  fee_transfer_id: String
  id: String!
  """
  An object relationship
  """
  redemption: redemptions
  redemption_id: String
  transaction_hash: bytea!
  """
  An object relationship
  """
  triple: triples
  triple_id: numeric
  type: event_type!
}

"""
aggregated selection of "event"
"""
type events_aggregate {
  aggregate: events_aggregate_fields
  nodes: [events!]!
}

input events_aggregate_bool_exp {
  count: events_aggregate_bool_exp_count
}

input events_aggregate_bool_exp_count {
  arguments: [events_select_column!]
  distinct: Boolean
  filter: events_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "event"
"""
type events_aggregate_fields {
  avg: events_avg_fields
  count(columns: [events_select_column!], distinct: Boolean): Int!
  max: events_max_fields
  min: events_min_fields
  stddev: events_stddev_fields
  stddev_pop: events_stddev_pop_fields
  stddev_samp: events_stddev_samp_fields
  sum: events_sum_fields
  var_pop: events_var_pop_fields
  var_samp: events_var_samp_fields
  variance: events_variance_fields
}

"""
order by aggregate values of table "event"
"""
input events_aggregate_order_by {
  avg: events_avg_order_by
  count: order_by
  max: events_max_order_by
  min: events_min_order_by
  stddev: events_stddev_order_by
  stddev_pop: events_stddev_pop_order_by
  stddev_samp: events_stddev_samp_order_by
  sum: events_sum_order_by
  var_pop: events_var_pop_order_by
  var_samp: events_var_samp_order_by
  variance: events_variance_order_by
}

"""
aggregate avg on columns
"""
type events_avg_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by avg() on columns of table "event"
"""
input events_avg_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
Boolean expression to filter rows from the table "event". All fields are combined with a logical 'AND'.
"""
input events_bool_exp {
  _and: [events_bool_exp!]
  _not: events_bool_exp
  _or: [events_bool_exp!]
  atom: atoms_bool_exp
  atom_id: numeric_comparison_exp
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  deposit: deposits_bool_exp
  deposit_id: String_comparison_exp
  fee_transfer: fee_transfers_bool_exp
  fee_transfer_id: String_comparison_exp
  id: String_comparison_exp
  redemption: redemptions_bool_exp
  redemption_id: String_comparison_exp
  transaction_hash: bytea_comparison_exp
  triple: triples_bool_exp
  triple_id: numeric_comparison_exp
  type: event_type_comparison_exp
}

"""
aggregate max on columns
"""
type events_max_fields {
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  deposit_id: String
  fee_transfer_id: String
  id: String
  redemption_id: String
  triple_id: numeric
  type: event_type
}

"""
order by max() on columns of table "event"
"""
input events_max_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  deposit_id: order_by
  fee_transfer_id: order_by
  id: order_by
  redemption_id: order_by
  triple_id: order_by
  type: order_by
}

"""
aggregate min on columns
"""
type events_min_fields {
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  deposit_id: String
  fee_transfer_id: String
  id: String
  redemption_id: String
  triple_id: numeric
  type: event_type
}

"""
order by min() on columns of table "event"
"""
input events_min_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  deposit_id: order_by
  fee_transfer_id: order_by
  id: order_by
  redemption_id: order_by
  triple_id: order_by
  type: order_by
}

"""
Ordering options when selecting data from "event".
"""
input events_order_by {
  atom: atoms_order_by
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  deposit: deposits_order_by
  deposit_id: order_by
  fee_transfer: fee_transfers_order_by
  fee_transfer_id: order_by
  id: order_by
  redemption: redemptions_order_by
  redemption_id: order_by
  transaction_hash: order_by
  triple: triples_order_by
  triple_id: order_by
  type: order_by
}

"""
select columns of table "event"
"""
enum events_select_column {
  """
  column name
  """
  atom_id
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  deposit_id
  """
  column name
  """
  fee_transfer_id
  """
  column name
  """
  id
  """
  column name
  """
  redemption_id
  """
  column name
  """
  transaction_hash
  """
  column name
  """
  triple_id
  """
  column name
  """
  type
}

"""
aggregate stddev on columns
"""
type events_stddev_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by stddev() on columns of table "event"
"""
input events_stddev_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type events_stddev_pop_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by stddev_pop() on columns of table "event"
"""
input events_stddev_pop_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type events_stddev_samp_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by stddev_samp() on columns of table "event"
"""
input events_stddev_samp_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
Streaming cursor of the table "events"
"""
input events_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: events_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input events_stream_cursor_value_input {
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  deposit_id: String
  fee_transfer_id: String
  id: String
  redemption_id: String
  transaction_hash: bytea
  triple_id: numeric
  type: event_type
}

"""
aggregate sum on columns
"""
type events_sum_fields {
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  triple_id: numeric
}

"""
order by sum() on columns of table "event"
"""
input events_sum_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
aggregate var_pop on columns
"""
type events_var_pop_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by var_pop() on columns of table "event"
"""
input events_var_pop_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
aggregate var_samp on columns
"""
type events_var_samp_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by var_samp() on columns of table "event"
"""
input events_var_samp_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
aggregate variance on columns
"""
type events_variance_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  triple_id: Float
}

"""
order by variance() on columns of table "event"
"""
input events_variance_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  triple_id: order_by
}

"""
columns and relationships of "fee_transfer"
"""
type fee_transfers {
  amount: numeric!
  block_number: numeric!
  block_timestamp: bigint!
  """
  An array relationship
  """
  events(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): [events!]!
  """
  An aggregate relationship
  """
  events_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): events_aggregate!
  id: String!
  """
  An object relationship
  """
  receiver: accounts!
  receiver_id: String!
  """
  An object relationship
  """
  sender: accounts
  sender_id: String!
  transaction_hash: bytea!
}

"""
aggregated selection of "fee_transfer"
"""
type fee_transfers_aggregate {
  aggregate: fee_transfers_aggregate_fields
  nodes: [fee_transfers!]!
}

input fee_transfers_aggregate_bool_exp {
  count: fee_transfers_aggregate_bool_exp_count
}

input fee_transfers_aggregate_bool_exp_count {
  arguments: [fee_transfers_select_column!]
  distinct: Boolean
  filter: fee_transfers_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "fee_transfer"
"""
type fee_transfers_aggregate_fields {
  avg: fee_transfers_avg_fields
  count(columns: [fee_transfers_select_column!], distinct: Boolean): Int!
  max: fee_transfers_max_fields
  min: fee_transfers_min_fields
  stddev: fee_transfers_stddev_fields
  stddev_pop: fee_transfers_stddev_pop_fields
  stddev_samp: fee_transfers_stddev_samp_fields
  sum: fee_transfers_sum_fields
  var_pop: fee_transfers_var_pop_fields
  var_samp: fee_transfers_var_samp_fields
  variance: fee_transfers_variance_fields
}

"""
order by aggregate values of table "fee_transfer"
"""
input fee_transfers_aggregate_order_by {
  avg: fee_transfers_avg_order_by
  count: order_by
  max: fee_transfers_max_order_by
  min: fee_transfers_min_order_by
  stddev: fee_transfers_stddev_order_by
  stddev_pop: fee_transfers_stddev_pop_order_by
  stddev_samp: fee_transfers_stddev_samp_order_by
  sum: fee_transfers_sum_order_by
  var_pop: fee_transfers_var_pop_order_by
  var_samp: fee_transfers_var_samp_order_by
  variance: fee_transfers_variance_order_by
}

"""
aggregate avg on columns
"""
type fee_transfers_avg_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by avg() on columns of table "fee_transfer"
"""
input fee_transfers_avg_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
Boolean expression to filter rows from the table "fee_transfer". All fields are combined with a logical 'AND'.
"""
input fee_transfers_bool_exp {
  _and: [fee_transfers_bool_exp!]
  _not: fee_transfers_bool_exp
  _or: [fee_transfers_bool_exp!]
  amount: numeric_comparison_exp
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  events: events_bool_exp
  events_aggregate: events_aggregate_bool_exp
  id: String_comparison_exp
  receiver: accounts_bool_exp
  receiver_id: String_comparison_exp
  sender: accounts_bool_exp
  sender_id: String_comparison_exp
  transaction_hash: bytea_comparison_exp
}

"""
aggregate max on columns
"""
type fee_transfers_max_fields {
  amount: numeric
  block_number: numeric
  block_timestamp: bigint
  id: String
  receiver_id: String
  sender_id: String
}

"""
order by max() on columns of table "fee_transfer"
"""
input fee_transfers_max_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  receiver_id: order_by
  sender_id: order_by
}

"""
aggregate min on columns
"""
type fee_transfers_min_fields {
  amount: numeric
  block_number: numeric
  block_timestamp: bigint
  id: String
  receiver_id: String
  sender_id: String
}

"""
order by min() on columns of table "fee_transfer"
"""
input fee_transfers_min_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
  id: order_by
  receiver_id: order_by
  sender_id: order_by
}

"""
Ordering options when selecting data from "fee_transfer".
"""
input fee_transfers_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
  events_aggregate: events_aggregate_order_by
  id: order_by
  receiver: accounts_order_by
  receiver_id: order_by
  sender: accounts_order_by
  sender_id: order_by
  transaction_hash: order_by
}

"""
select columns of table "fee_transfer"
"""
enum fee_transfers_select_column {
  """
  column name
  """
  amount
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  id
  """
  column name
  """
  receiver_id
  """
  column name
  """
  sender_id
  """
  column name
  """
  transaction_hash
}

"""
aggregate stddev on columns
"""
type fee_transfers_stddev_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by stddev() on columns of table "fee_transfer"
"""
input fee_transfers_stddev_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
aggregate stddev_pop on columns
"""
type fee_transfers_stddev_pop_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by stddev_pop() on columns of table "fee_transfer"
"""
input fee_transfers_stddev_pop_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
aggregate stddev_samp on columns
"""
type fee_transfers_stddev_samp_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by stddev_samp() on columns of table "fee_transfer"
"""
input fee_transfers_stddev_samp_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
Streaming cursor of the table "fee_transfers"
"""
input fee_transfers_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: fee_transfers_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input fee_transfers_stream_cursor_value_input {
  amount: numeric
  block_number: numeric
  block_timestamp: bigint
  id: String
  receiver_id: String
  sender_id: String
  transaction_hash: bytea
}

"""
aggregate sum on columns
"""
type fee_transfers_sum_fields {
  amount: numeric
  block_number: numeric
  block_timestamp: bigint
}

"""
order by sum() on columns of table "fee_transfer"
"""
input fee_transfers_sum_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
aggregate var_pop on columns
"""
type fee_transfers_var_pop_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by var_pop() on columns of table "fee_transfer"
"""
input fee_transfers_var_pop_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
aggregate var_samp on columns
"""
type fee_transfers_var_samp_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by var_samp() on columns of table "fee_transfer"
"""
input fee_transfers_var_samp_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

"""
aggregate variance on columns
"""
type fee_transfers_variance_fields {
  amount: Float
  block_number: Float
  block_timestamp: Float
}

"""
order by variance() on columns of table "fee_transfer"
"""
input fee_transfers_variance_order_by {
  amount: order_by
  block_number: order_by
  block_timestamp: order_by
}

scalar float8

"""
Boolean expression to compare columns of type "float8". All fields are combined with logical 'AND'.
"""
input float8_comparison_exp {
  _eq: float8
  _gt: float8
  _gte: float8
  _in: [float8!]
  _is_null: Boolean
  _lt: float8
  _lte: float8
  _neq: float8
  _nin: [float8!]
}

input following_args {
  address: String
}

scalar jsonb

input jsonb_cast_exp {
  String: String_comparison_exp
}

"""
Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'.
"""
input jsonb_comparison_exp {
  _cast: jsonb_cast_exp
  """
  is the column contained in the given json value
  """
  _contained_in: jsonb
  """
  does the column contain the given json value at the top level
  """
  _contains: jsonb
  _eq: jsonb
  _gt: jsonb
  _gte: jsonb
  """
  does the string exist as a top-level key in the column
  """
  _has_key: String
  """
  do all of these strings exist as top-level keys in the column
  """
  _has_keys_all: [String!]
  """
  do any of these strings exist as top-level keys in the column
  """
  _has_keys_any: [String!]
  _in: [jsonb!]
  _is_null: Boolean
  _lt: jsonb
  _lte: jsonb
  _neq: jsonb
  _nin: [jsonb!]
}

"""
mutation root
"""
type mutation_root {
  """
  Uploads and pins Organization to IPFS
  """
  pinOrganization(organization: PinOrganizationInput!): PinOutput
  """
  Uploads and pins Person to IPFS
  """
  pinPerson(person: PinPersonInput!): PinOutput
  """
  Uploads and pins Thing to IPFS
  """
  pinThing(thing: PinThingInput!): PinOutput
}

scalar numeric

"""
Boolean expression to compare columns of type "numeric". All fields are combined with logical 'AND'.
"""
input numeric_comparison_exp {
  _eq: numeric
  _gt: numeric
  _gte: numeric
  _in: [numeric!]
  _is_null: Boolean
  _lt: numeric
  _lte: numeric
  _neq: numeric
  _nin: [numeric!]
}

"""
column ordering options
"""
enum order_by {
  """
  in ascending order, nulls last
  """
  asc
  """
  in ascending order, nulls first
  """
  asc_nulls_first
  """
  in ascending order, nulls last
  """
  asc_nulls_last
  """
  in descending order, nulls first
  """
  desc
  """
  in descending order, nulls first
  """
  desc_nulls_first
  """
  in descending order, nulls last
  """
  desc_nulls_last
}

"""
columns and relationships of "organization"
"""
type organizations {
  """
  An object relationship
  """
  atom: atoms
  """
  An object relationship
  """
  cached_image: cached_images
  description: String
  email: String
  id: numeric!
  image: String
  name: String
  url: String
}

"""
aggregated selection of "organization"
"""
type organizations_aggregate {
  aggregate: organizations_aggregate_fields
  nodes: [organizations!]!
}

"""
aggregate fields of "organization"
"""
type organizations_aggregate_fields {
  avg: organizations_avg_fields
  count(columns: [organizations_select_column!], distinct: Boolean): Int!
  max: organizations_max_fields
  min: organizations_min_fields
  stddev: organizations_stddev_fields
  stddev_pop: organizations_stddev_pop_fields
  stddev_samp: organizations_stddev_samp_fields
  sum: organizations_sum_fields
  var_pop: organizations_var_pop_fields
  var_samp: organizations_var_samp_fields
  variance: organizations_variance_fields
}

"""
aggregate avg on columns
"""
type organizations_avg_fields {
  id: Float
}

"""
Boolean expression to filter rows from the table "organization". All fields are combined with a logical 'AND'.
"""
input organizations_bool_exp {
  _and: [organizations_bool_exp!]
  _not: organizations_bool_exp
  _or: [organizations_bool_exp!]
  atom: atoms_bool_exp
  cached_image: cached_images_bool_exp
  description: String_comparison_exp
  email: String_comparison_exp
  id: numeric_comparison_exp
  image: String_comparison_exp
  name: String_comparison_exp
  url: String_comparison_exp
}

"""
aggregate max on columns
"""
type organizations_max_fields {
  description: String
  email: String
  id: numeric
  image: String
  name: String
  url: String
}

"""
aggregate min on columns
"""
type organizations_min_fields {
  description: String
  email: String
  id: numeric
  image: String
  name: String
  url: String
}

"""
Ordering options when selecting data from "organization".
"""
input organizations_order_by {
  atom: atoms_order_by
  cached_image: cached_images_order_by
  description: order_by
  email: order_by
  id: order_by
  image: order_by
  name: order_by
  url: order_by
}

"""
select columns of table "organization"
"""
enum organizations_select_column {
  """
  column name
  """
  description
  """
  column name
  """
  email
  """
  column name
  """
  id
  """
  column name
  """
  image
  """
  column name
  """
  name
  """
  column name
  """
  url
}

"""
aggregate stddev on columns
"""
type organizations_stddev_fields {
  id: Float
}

"""
aggregate stddev_pop on columns
"""
type organizations_stddev_pop_fields {
  id: Float
}

"""
aggregate stddev_samp on columns
"""
type organizations_stddev_samp_fields {
  id: Float
}

"""
Streaming cursor of the table "organizations"
"""
input organizations_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: organizations_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input organizations_stream_cursor_value_input {
  description: String
  email: String
  id: numeric
  image: String
  name: String
  url: String
}

"""
aggregate sum on columns
"""
type organizations_sum_fields {
  id: numeric
}

"""
aggregate var_pop on columns
"""
type organizations_var_pop_fields {
  id: Float
}

"""
aggregate var_samp on columns
"""
type organizations_var_samp_fields {
  id: Float
}

"""
aggregate variance on columns
"""
type organizations_variance_fields {
  id: Float
}

"""
columns and relationships of "person"
"""
type persons {
  """
  An object relationship
  """
  atom: atoms
  """
  An object relationship
  """
  cached_image: cached_images
  description: String
  email: String
  id: numeric!
  identifier: String
  image: String
  name: String
  url: String
}

"""
aggregated selection of "person"
"""
type persons_aggregate {
  aggregate: persons_aggregate_fields
  nodes: [persons!]!
}

"""
aggregate fields of "person"
"""
type persons_aggregate_fields {
  avg: persons_avg_fields
  count(columns: [persons_select_column!], distinct: Boolean): Int!
  max: persons_max_fields
  min: persons_min_fields
  stddev: persons_stddev_fields
  stddev_pop: persons_stddev_pop_fields
  stddev_samp: persons_stddev_samp_fields
  sum: persons_sum_fields
  var_pop: persons_var_pop_fields
  var_samp: persons_var_samp_fields
  variance: persons_variance_fields
}

"""
aggregate avg on columns
"""
type persons_avg_fields {
  id: Float
}

"""
Boolean expression to filter rows from the table "person". All fields are combined with a logical 'AND'.
"""
input persons_bool_exp {
  _and: [persons_bool_exp!]
  _not: persons_bool_exp
  _or: [persons_bool_exp!]
  atom: atoms_bool_exp
  cached_image: cached_images_bool_exp
  description: String_comparison_exp
  email: String_comparison_exp
  id: numeric_comparison_exp
  identifier: String_comparison_exp
  image: String_comparison_exp
  name: String_comparison_exp
  url: String_comparison_exp
}

"""
aggregate max on columns
"""
type persons_max_fields {
  description: String
  email: String
  id: numeric
  identifier: String
  image: String
  name: String
  url: String
}

"""
aggregate min on columns
"""
type persons_min_fields {
  description: String
  email: String
  id: numeric
  identifier: String
  image: String
  name: String
  url: String
}

"""
Ordering options when selecting data from "person".
"""
input persons_order_by {
  atom: atoms_order_by
  cached_image: cached_images_order_by
  description: order_by
  email: order_by
  id: order_by
  identifier: order_by
  image: order_by
  name: order_by
  url: order_by
}

"""
select columns of table "person"
"""
enum persons_select_column {
  """
  column name
  """
  description
  """
  column name
  """
  email
  """
  column name
  """
  id
  """
  column name
  """
  identifier
  """
  column name
  """
  image
  """
  column name
  """
  name
  """
  column name
  """
  url
}

"""
aggregate stddev on columns
"""
type persons_stddev_fields {
  id: Float
}

"""
aggregate stddev_pop on columns
"""
type persons_stddev_pop_fields {
  id: Float
}

"""
aggregate stddev_samp on columns
"""
type persons_stddev_samp_fields {
  id: Float
}

"""
Streaming cursor of the table "persons"
"""
input persons_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: persons_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input persons_stream_cursor_value_input {
  description: String
  email: String
  id: numeric
  identifier: String
  image: String
  name: String
  url: String
}

"""
aggregate sum on columns
"""
type persons_sum_fields {
  id: numeric
}

"""
aggregate var_pop on columns
"""
type persons_var_pop_fields {
  id: Float
}

"""
aggregate var_samp on columns
"""
type persons_var_samp_fields {
  id: Float
}

"""
aggregate variance on columns
"""
type persons_variance_fields {
  id: Float
}

"""
columns and relationships of "position"
"""
type positions {
  """
  An object relationship
  """
  account: accounts
  account_id: String!
  id: String!
  shares: numeric!
  """
  An object relationship
  """
  vault: vaults!
  vault_id: numeric!
}

"""
aggregated selection of "position"
"""
type positions_aggregate {
  aggregate: positions_aggregate_fields
  nodes: [positions!]!
}

input positions_aggregate_bool_exp {
  count: positions_aggregate_bool_exp_count
}

input positions_aggregate_bool_exp_count {
  arguments: [positions_select_column!]
  distinct: Boolean
  filter: positions_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "position"
"""
type positions_aggregate_fields {
  avg: positions_avg_fields
  count(columns: [positions_select_column!], distinct: Boolean): Int!
  max: positions_max_fields
  min: positions_min_fields
  stddev: positions_stddev_fields
  stddev_pop: positions_stddev_pop_fields
  stddev_samp: positions_stddev_samp_fields
  sum: positions_sum_fields
  var_pop: positions_var_pop_fields
  var_samp: positions_var_samp_fields
  variance: positions_variance_fields
}

"""
order by aggregate values of table "position"
"""
input positions_aggregate_order_by {
  avg: positions_avg_order_by
  count: order_by
  max: positions_max_order_by
  min: positions_min_order_by
  stddev: positions_stddev_order_by
  stddev_pop: positions_stddev_pop_order_by
  stddev_samp: positions_stddev_samp_order_by
  sum: positions_sum_order_by
  var_pop: positions_var_pop_order_by
  var_samp: positions_var_samp_order_by
  variance: positions_variance_order_by
}

"""
aggregate avg on columns
"""
type positions_avg_fields {
  shares: Float
  vault_id: Float
}

"""
order by avg() on columns of table "position"
"""
input positions_avg_order_by {
  shares: order_by
  vault_id: order_by
}

"""
Boolean expression to filter rows from the table "position". All fields are combined with a logical 'AND'.
"""
input positions_bool_exp {
  _and: [positions_bool_exp!]
  _not: positions_bool_exp
  _or: [positions_bool_exp!]
  account: accounts_bool_exp
  account_id: String_comparison_exp
  id: String_comparison_exp
  shares: numeric_comparison_exp
  vault: vaults_bool_exp
  vault_id: numeric_comparison_exp
}

"""
aggregate max on columns
"""
type positions_max_fields {
  account_id: String
  id: String
  shares: numeric
  vault_id: numeric
}

"""
order by max() on columns of table "position"
"""
input positions_max_order_by {
  account_id: order_by
  id: order_by
  shares: order_by
  vault_id: order_by
}

"""
aggregate min on columns
"""
type positions_min_fields {
  account_id: String
  id: String
  shares: numeric
  vault_id: numeric
}

"""
order by min() on columns of table "position"
"""
input positions_min_order_by {
  account_id: order_by
  id: order_by
  shares: order_by
  vault_id: order_by
}

"""
Ordering options when selecting data from "position".
"""
input positions_order_by {
  account: accounts_order_by
  account_id: order_by
  id: order_by
  shares: order_by
  vault: vaults_order_by
  vault_id: order_by
}

"""
select columns of table "position"
"""
enum positions_select_column {
  """
  column name
  """
  account_id
  """
  column name
  """
  id
  """
  column name
  """
  shares
  """
  column name
  """
  vault_id
}

"""
aggregate stddev on columns
"""
type positions_stddev_fields {
  shares: Float
  vault_id: Float
}

"""
order by stddev() on columns of table "position"
"""
input positions_stddev_order_by {
  shares: order_by
  vault_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type positions_stddev_pop_fields {
  shares: Float
  vault_id: Float
}

"""
order by stddev_pop() on columns of table "position"
"""
input positions_stddev_pop_order_by {
  shares: order_by
  vault_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type positions_stddev_samp_fields {
  shares: Float
  vault_id: Float
}

"""
order by stddev_samp() on columns of table "position"
"""
input positions_stddev_samp_order_by {
  shares: order_by
  vault_id: order_by
}

"""
Streaming cursor of the table "positions"
"""
input positions_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: positions_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input positions_stream_cursor_value_input {
  account_id: String
  id: String
  shares: numeric
  vault_id: numeric
}

"""
aggregate sum on columns
"""
type positions_sum_fields {
  shares: numeric
  vault_id: numeric
}

"""
order by sum() on columns of table "position"
"""
input positions_sum_order_by {
  shares: order_by
  vault_id: order_by
}

"""
aggregate var_pop on columns
"""
type positions_var_pop_fields {
  shares: Float
  vault_id: Float
}

"""
order by var_pop() on columns of table "position"
"""
input positions_var_pop_order_by {
  shares: order_by
  vault_id: order_by
}

"""
aggregate var_samp on columns
"""
type positions_var_samp_fields {
  shares: Float
  vault_id: Float
}

"""
order by var_samp() on columns of table "position"
"""
input positions_var_samp_order_by {
  shares: order_by
  vault_id: order_by
}

"""
aggregate variance on columns
"""
type positions_variance_fields {
  shares: Float
  vault_id: Float
}

"""
order by variance() on columns of table "position"
"""
input positions_variance_order_by {
  shares: order_by
  vault_id: order_by
}

"""
columns and relationships of "predicate_object"
"""
type predicate_objects {
  claim_count: Int!
  id: String!
  """
  An object relationship
  """
  object: atoms!
  object_id: numeric!
  """
  An object relationship
  """
  predicate: atoms
  predicate_id: numeric!
  triple_count: Int!
}

"""
aggregated selection of "predicate_object"
"""
type predicate_objects_aggregate {
  aggregate: predicate_objects_aggregate_fields
  nodes: [predicate_objects!]!
}

"""
aggregate fields of "predicate_object"
"""
type predicate_objects_aggregate_fields {
  avg: predicate_objects_avg_fields
  count(columns: [predicate_objects_select_column!], distinct: Boolean): Int!
  max: predicate_objects_max_fields
  min: predicate_objects_min_fields
  stddev: predicate_objects_stddev_fields
  stddev_pop: predicate_objects_stddev_pop_fields
  stddev_samp: predicate_objects_stddev_samp_fields
  sum: predicate_objects_sum_fields
  var_pop: predicate_objects_var_pop_fields
  var_samp: predicate_objects_var_samp_fields
  variance: predicate_objects_variance_fields
}

"""
aggregate avg on columns
"""
type predicate_objects_avg_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

"""
Boolean expression to filter rows from the table "predicate_object". All fields are combined with a logical 'AND'.
"""
input predicate_objects_bool_exp {
  _and: [predicate_objects_bool_exp!]
  _not: predicate_objects_bool_exp
  _or: [predicate_objects_bool_exp!]
  claim_count: Int_comparison_exp
  id: String_comparison_exp
  object: atoms_bool_exp
  object_id: numeric_comparison_exp
  predicate: atoms_bool_exp
  predicate_id: numeric_comparison_exp
  triple_count: Int_comparison_exp
}

"""
aggregate max on columns
"""
type predicate_objects_max_fields {
  claim_count: Int
  id: String
  object_id: numeric
  predicate_id: numeric
  triple_count: Int
}

"""
aggregate min on columns
"""
type predicate_objects_min_fields {
  claim_count: Int
  id: String
  object_id: numeric
  predicate_id: numeric
  triple_count: Int
}

"""
Ordering options when selecting data from "predicate_object".
"""
input predicate_objects_order_by {
  claim_count: order_by
  id: order_by
  object: atoms_order_by
  object_id: order_by
  predicate: atoms_order_by
  predicate_id: order_by
  triple_count: order_by
}

"""
select columns of table "predicate_object"
"""
enum predicate_objects_select_column {
  """
  column name
  """
  claim_count
  """
  column name
  """
  id
  """
  column name
  """
  object_id
  """
  column name
  """
  predicate_id
  """
  column name
  """
  triple_count
}

"""
aggregate stddev on columns
"""
type predicate_objects_stddev_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

"""
aggregate stddev_pop on columns
"""
type predicate_objects_stddev_pop_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

"""
aggregate stddev_samp on columns
"""
type predicate_objects_stddev_samp_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

"""
Streaming cursor of the table "predicate_objects"
"""
input predicate_objects_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: predicate_objects_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input predicate_objects_stream_cursor_value_input {
  claim_count: Int
  id: String
  object_id: numeric
  predicate_id: numeric
  triple_count: Int
}

"""
aggregate sum on columns
"""
type predicate_objects_sum_fields {
  claim_count: Int
  object_id: numeric
  predicate_id: numeric
  triple_count: Int
}

"""
aggregate var_pop on columns
"""
type predicate_objects_var_pop_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

"""
aggregate var_samp on columns
"""
type predicate_objects_var_samp_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

"""
aggregate variance on columns
"""
type predicate_objects_variance_fields {
  claim_count: Float
  object_id: Float
  predicate_id: Float
  triple_count: Float
}

type query_root {
  """
  fetch data from the table: "account" using primary key columns
  """
  account(id: String!): accounts
  """
  An array relationship
  """
  accounts(
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  An aggregate relationship
  """
  accounts_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  execute function "accounts_that_claim_about_account" which returns "account"
  """
  accounts_that_claim_about_account(
    """
    input parameters for function "accounts_that_claim_about_account"
    """
    args: accounts_that_claim_about_account_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  execute function "accounts_that_claim_about_account" and query aggregates on result of table type "account"
  """
  accounts_that_claim_about_account_aggregate(
    """
    input parameters for function "accounts_that_claim_about_account_aggregate"
    """
    args: accounts_that_claim_about_account_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  fetch data from the table: "atom" using primary key columns
  """
  atom(id: numeric!): atoms
  """
  fetch data from the table: "atom_value" using primary key columns
  """
  atom_value(id: numeric!): atom_values
  """
  fetch data from the table: "atom_value"
  """
  atom_values(
    """
    distinct select on columns
    """
    distinct_on: [atom_values_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atom_values_order_by!]
    """
    filter the rows returned
    """
    where: atom_values_bool_exp
  ): [atom_values!]!
  """
  fetch aggregated fields from the table: "atom_value"
  """
  atom_values_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [atom_values_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atom_values_order_by!]
    """
    filter the rows returned
    """
    where: atom_values_bool_exp
  ): atom_values_aggregate!
  """
  An array relationship
  """
  atoms(
    """
    distinct select on columns
    """
    distinct_on: [atoms_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atoms_order_by!]
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): [atoms!]!
  """
  An aggregate relationship
  """
  atoms_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [atoms_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atoms_order_by!]
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): atoms_aggregate!
  """
  fetch data from the table: "book" using primary key columns
  """
  book(id: numeric!): books
  """
  fetch data from the table: "book"
  """
  books(
    """
    distinct select on columns
    """
    distinct_on: [books_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [books_order_by!]
    """
    filter the rows returned
    """
    where: books_bool_exp
  ): [books!]!
  """
  fetch aggregated fields from the table: "book"
  """
  books_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [books_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [books_order_by!]
    """
    filter the rows returned
    """
    where: books_bool_exp
  ): books_aggregate!
  """
  fetch data from the table: "cached_image" using primary key columns
  """
  cached_image(url: String!): cached_images
  """
  fetch data from the table: "cached_image"
  """
  cached_images(
    """
    distinct select on columns
    """
    distinct_on: [cached_images_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [cached_images_order_by!]
    """
    filter the rows returned
    """
    where: cached_images_bool_exp
  ): [cached_images!]!
  """
  fetch data from the table: "chainlink_price" using primary key columns
  """
  chainlink_price(id: numeric!): chainlink_prices
  """
  fetch data from the table: "chainlink_price"
  """
  chainlink_prices(
    """
    distinct select on columns
    """
    distinct_on: [chainlink_prices_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [chainlink_prices_order_by!]
    """
    filter the rows returned
    """
    where: chainlink_prices_bool_exp
  ): [chainlink_prices!]!
  """
  fetch data from the table: "claim" using primary key columns
  """
  claim(id: String!): claims
  """
  An array relationship
  """
  claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  execute function "claims_from_following" which returns "claim"
  """
  claims_from_following(
    """
    input parameters for function "claims_from_following"
    """
    args: claims_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  execute function "claims_from_following" and query aggregates on result of table type "claim"
  """
  claims_from_following_aggregate(
    """
    input parameters for function "claims_from_following_aggregate"
    """
    args: claims_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  fetch data from the table: "deposit" using primary key columns
  """
  deposit(id: String!): deposits
  """
  An array relationship
  """
  deposits(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): [deposits!]!
  """
  An aggregate relationship
  """
  deposits_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): deposits_aggregate!
  """
  fetch data from the table: "event" using primary key columns
  """
  event(id: String!): events
  """
  An array relationship
  """
  events(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): [events!]!
  """
  An aggregate relationship
  """
  events_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): events_aggregate!
  """
  fetch data from the table: "fee_transfer" using primary key columns
  """
  fee_transfer(id: String!): fee_transfers
  """
  An array relationship
  """
  fee_transfers(
    """
    distinct select on columns
    """
    distinct_on: [fee_transfers_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [fee_transfers_order_by!]
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): [fee_transfers!]!
  """
  An aggregate relationship
  """
  fee_transfers_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [fee_transfers_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [fee_transfers_order_by!]
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): fee_transfers_aggregate!
  """
  execute function "following" which returns "account"
  """
  following(
    """
    input parameters for function "following"
    """
    args: following_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  execute function "following" and query aggregates on result of table type "account"
  """
  following_aggregate(
    """
    input parameters for function "following_aggregate"
    """
    args: following_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  fetch data from the table: "organization" using primary key columns
  """
  organization(id: numeric!): organizations
  """
  fetch data from the table: "organization"
  """
  organizations(
    """
    distinct select on columns
    """
    distinct_on: [organizations_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [organizations_order_by!]
    """
    filter the rows returned
    """
    where: organizations_bool_exp
  ): [organizations!]!
  """
  fetch aggregated fields from the table: "organization"
  """
  organizations_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [organizations_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [organizations_order_by!]
    """
    filter the rows returned
    """
    where: organizations_bool_exp
  ): organizations_aggregate!
  """
  fetch data from the table: "person" using primary key columns
  """
  person(id: numeric!): persons
  """
  fetch data from the table: "person"
  """
  persons(
    """
    distinct select on columns
    """
    distinct_on: [persons_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [persons_order_by!]
    """
    filter the rows returned
    """
    where: persons_bool_exp
  ): [persons!]!
  """
  fetch aggregated fields from the table: "person"
  """
  persons_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [persons_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [persons_order_by!]
    """
    filter the rows returned
    """
    where: persons_bool_exp
  ): persons_aggregate!
  """
  fetch data from the table: "position" using primary key columns
  """
  position(id: String!): positions
  """
  An array relationship
  """
  positions(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): [positions!]!
  """
  An aggregate relationship
  """
  positions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): positions_aggregate!
  """
  fetch data from the table: "predicate_object"
  """
  predicate_objects(
    """
    distinct select on columns
    """
    distinct_on: [predicate_objects_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [predicate_objects_order_by!]
    """
    filter the rows returned
    """
    where: predicate_objects_bool_exp
  ): [predicate_objects!]!
  """
  fetch aggregated fields from the table: "predicate_object"
  """
  predicate_objects_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [predicate_objects_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [predicate_objects_order_by!]
    """
    filter the rows returned
    """
    where: predicate_objects_bool_exp
  ): predicate_objects_aggregate!
  """
  fetch data from the table: "predicate_object" using primary key columns
  """
  predicate_objects_by_pk(id: String!): predicate_objects
  """
  fetch data from the table: "redemption" using primary key columns
  """
  redemption(id: String!): redemptions
  """
  An array relationship
  """
  redemptions(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): [redemptions!]!
  """
  An aggregate relationship
  """
  redemptions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): redemptions_aggregate!
  """
  fetch data from the table: "signal" using primary key columns
  """
  signal(id: String!): signals
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  """
  execute function "signals_from_following" which returns "signal"
  """
  signals_from_following(
    """
    input parameters for function "signals_from_following"
    """
    args: signals_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  execute function "signals_from_following" and query aggregates on result of table type "signal"
  """
  signals_from_following_aggregate(
    """
    input parameters for function "signals_from_following_aggregate"
    """
    args: signals_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  """
  fetch data from the table: "stats" using primary key columns
  """
  stat(id: Int!): stats
  """
  fetch data from the table: "stats"
  """
  stats(
    """
    distinct select on columns
    """
    distinct_on: [stats_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [stats_order_by!]
    """
    filter the rows returned
    """
    where: stats_bool_exp
  ): [stats!]!
  """
  fetch aggregated fields from the table: "stats"
  """
  stats_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [stats_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [stats_order_by!]
    """
    filter the rows returned
    """
    where: stats_bool_exp
  ): stats_aggregate!
  """
  fetch data from the table: "thing" using primary key columns
  """
  thing(id: numeric!): things
  """
  fetch data from the table: "thing"
  """
  things(
    """
    distinct select on columns
    """
    distinct_on: [things_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [things_order_by!]
    """
    filter the rows returned
    """
    where: things_bool_exp
  ): [things!]!
  """
  fetch aggregated fields from the table: "thing"
  """
  things_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [things_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [things_order_by!]
    """
    filter the rows returned
    """
    where: things_bool_exp
  ): things_aggregate!
  """
  fetch data from the table: "triple" using primary key columns
  """
  triple(id: numeric!): triples
  """
  An array relationship
  """
  triples(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  An aggregate relationship
  """
  triples_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): triples_aggregate!
  """
  fetch data from the table: "vault" using primary key columns
  """
  vault(id: numeric!): vaults
  """
  fetch data from the table: "vault"
  """
  vaults(
    """
    distinct select on columns
    """
    distinct_on: [vaults_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [vaults_order_by!]
    """
    filter the rows returned
    """
    where: vaults_bool_exp
  ): [vaults!]!
  """
  fetch aggregated fields from the table: "vault"
  """
  vaults_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [vaults_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [vaults_order_by!]
    """
    filter the rows returned
    """
    where: vaults_bool_exp
  ): vaults_aggregate!
}

"""
columns and relationships of "redemption"
"""
type redemptions {
  assets_for_receiver: numeric!
  block_number: numeric!
  block_timestamp: bigint!
  """
  An array relationship
  """
  events(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): [events!]!
  """
  An aggregate relationship
  """
  events_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): events_aggregate!
  exit_fee: numeric!
  id: String!
  """
  An object relationship
  """
  receiver: accounts!
  receiver_id: String!
  """
  An object relationship
  """
  sender: accounts
  sender_id: String!
  sender_total_shares_in_vault: numeric!
  shares_redeemed_by_sender: numeric!
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  transaction_hash: bytea!
  """
  An object relationship
  """
  vault: vaults!
  vault_id: numeric!
}

"""
aggregated selection of "redemption"
"""
type redemptions_aggregate {
  aggregate: redemptions_aggregate_fields
  nodes: [redemptions!]!
}

input redemptions_aggregate_bool_exp {
  count: redemptions_aggregate_bool_exp_count
}

input redemptions_aggregate_bool_exp_count {
  arguments: [redemptions_select_column!]
  distinct: Boolean
  filter: redemptions_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "redemption"
"""
type redemptions_aggregate_fields {
  avg: redemptions_avg_fields
  count(columns: [redemptions_select_column!], distinct: Boolean): Int!
  max: redemptions_max_fields
  min: redemptions_min_fields
  stddev: redemptions_stddev_fields
  stddev_pop: redemptions_stddev_pop_fields
  stddev_samp: redemptions_stddev_samp_fields
  sum: redemptions_sum_fields
  var_pop: redemptions_var_pop_fields
  var_samp: redemptions_var_samp_fields
  variance: redemptions_variance_fields
}

"""
order by aggregate values of table "redemption"
"""
input redemptions_aggregate_order_by {
  avg: redemptions_avg_order_by
  count: order_by
  max: redemptions_max_order_by
  min: redemptions_min_order_by
  stddev: redemptions_stddev_order_by
  stddev_pop: redemptions_stddev_pop_order_by
  stddev_samp: redemptions_stddev_samp_order_by
  sum: redemptions_sum_order_by
  var_pop: redemptions_var_pop_order_by
  var_samp: redemptions_var_samp_order_by
  variance: redemptions_variance_order_by
}

"""
aggregate avg on columns
"""
type redemptions_avg_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by avg() on columns of table "redemption"
"""
input redemptions_avg_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
Boolean expression to filter rows from the table "redemption". All fields are combined with a logical 'AND'.
"""
input redemptions_bool_exp {
  _and: [redemptions_bool_exp!]
  _not: redemptions_bool_exp
  _or: [redemptions_bool_exp!]
  assets_for_receiver: numeric_comparison_exp
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  events: events_bool_exp
  events_aggregate: events_aggregate_bool_exp
  exit_fee: numeric_comparison_exp
  id: String_comparison_exp
  receiver: accounts_bool_exp
  receiver_id: String_comparison_exp
  sender: accounts_bool_exp
  sender_id: String_comparison_exp
  sender_total_shares_in_vault: numeric_comparison_exp
  shares_redeemed_by_sender: numeric_comparison_exp
  signals: signals_bool_exp
  signals_aggregate: signals_aggregate_bool_exp
  transaction_hash: bytea_comparison_exp
  vault: vaults_bool_exp
  vault_id: numeric_comparison_exp
}

"""
aggregate max on columns
"""
type redemptions_max_fields {
  assets_for_receiver: numeric
  block_number: numeric
  block_timestamp: bigint
  exit_fee: numeric
  id: String
  receiver_id: String
  sender_id: String
  sender_total_shares_in_vault: numeric
  shares_redeemed_by_sender: numeric
  vault_id: numeric
}

"""
order by max() on columns of table "redemption"
"""
input redemptions_max_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  id: order_by
  receiver_id: order_by
  sender_id: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
aggregate min on columns
"""
type redemptions_min_fields {
  assets_for_receiver: numeric
  block_number: numeric
  block_timestamp: bigint
  exit_fee: numeric
  id: String
  receiver_id: String
  sender_id: String
  sender_total_shares_in_vault: numeric
  shares_redeemed_by_sender: numeric
  vault_id: numeric
}

"""
order by min() on columns of table "redemption"
"""
input redemptions_min_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  id: order_by
  receiver_id: order_by
  sender_id: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
Ordering options when selecting data from "redemption".
"""
input redemptions_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  events_aggregate: events_aggregate_order_by
  exit_fee: order_by
  id: order_by
  receiver: accounts_order_by
  receiver_id: order_by
  sender: accounts_order_by
  sender_id: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  signals_aggregate: signals_aggregate_order_by
  transaction_hash: order_by
  vault: vaults_order_by
  vault_id: order_by
}

"""
select columns of table "redemption"
"""
enum redemptions_select_column {
  """
  column name
  """
  assets_for_receiver
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  exit_fee
  """
  column name
  """
  id
  """
  column name
  """
  receiver_id
  """
  column name
  """
  sender_id
  """
  column name
  """
  sender_total_shares_in_vault
  """
  column name
  """
  shares_redeemed_by_sender
  """
  column name
  """
  transaction_hash
  """
  column name
  """
  vault_id
}

"""
aggregate stddev on columns
"""
type redemptions_stddev_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by stddev() on columns of table "redemption"
"""
input redemptions_stddev_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type redemptions_stddev_pop_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by stddev_pop() on columns of table "redemption"
"""
input redemptions_stddev_pop_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type redemptions_stddev_samp_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by stddev_samp() on columns of table "redemption"
"""
input redemptions_stddev_samp_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
Streaming cursor of the table "redemptions"
"""
input redemptions_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: redemptions_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input redemptions_stream_cursor_value_input {
  assets_for_receiver: numeric
  block_number: numeric
  block_timestamp: bigint
  exit_fee: numeric
  id: String
  receiver_id: String
  sender_id: String
  sender_total_shares_in_vault: numeric
  shares_redeemed_by_sender: numeric
  transaction_hash: bytea
  vault_id: numeric
}

"""
aggregate sum on columns
"""
type redemptions_sum_fields {
  assets_for_receiver: numeric
  block_number: numeric
  block_timestamp: bigint
  exit_fee: numeric
  sender_total_shares_in_vault: numeric
  shares_redeemed_by_sender: numeric
  vault_id: numeric
}

"""
order by sum() on columns of table "redemption"
"""
input redemptions_sum_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
aggregate var_pop on columns
"""
type redemptions_var_pop_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by var_pop() on columns of table "redemption"
"""
input redemptions_var_pop_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
aggregate var_samp on columns
"""
type redemptions_var_samp_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by var_samp() on columns of table "redemption"
"""
input redemptions_var_samp_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
aggregate variance on columns
"""
type redemptions_variance_fields {
  assets_for_receiver: Float
  block_number: Float
  block_timestamp: Float
  exit_fee: Float
  sender_total_shares_in_vault: Float
  shares_redeemed_by_sender: Float
  vault_id: Float
}

"""
order by variance() on columns of table "redemption"
"""
input redemptions_variance_order_by {
  assets_for_receiver: order_by
  block_number: order_by
  block_timestamp: order_by
  exit_fee: order_by
  sender_total_shares_in_vault: order_by
  shares_redeemed_by_sender: order_by
  vault_id: order_by
}

"""
columns and relationships of "signal"
"""
type signals {
  """
  An object relationship
  """
  account: accounts
  account_id: String!
  """
  An object relationship
  """
  atom: atoms
  atom_id: numeric
  block_number: numeric!
  block_timestamp: bigint!
  delta: numeric!
  """
  An object relationship
  """
  deposit: deposits
  deposit_id: String
  id: String!
  """
  An object relationship
  """
  redemption: redemptions
  redemption_id: String
  transaction_hash: bytea!
  """
  An object relationship
  """
  triple: triples
  triple_id: numeric
}

"""
aggregated selection of "signal"
"""
type signals_aggregate {
  aggregate: signals_aggregate_fields
  nodes: [signals!]!
}

input signals_aggregate_bool_exp {
  count: signals_aggregate_bool_exp_count
}

input signals_aggregate_bool_exp_count {
  arguments: [signals_select_column!]
  distinct: Boolean
  filter: signals_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "signal"
"""
type signals_aggregate_fields {
  avg: signals_avg_fields
  count(columns: [signals_select_column!], distinct: Boolean): Int!
  max: signals_max_fields
  min: signals_min_fields
  stddev: signals_stddev_fields
  stddev_pop: signals_stddev_pop_fields
  stddev_samp: signals_stddev_samp_fields
  sum: signals_sum_fields
  var_pop: signals_var_pop_fields
  var_samp: signals_var_samp_fields
  variance: signals_variance_fields
}

"""
order by aggregate values of table "signal"
"""
input signals_aggregate_order_by {
  avg: signals_avg_order_by
  count: order_by
  max: signals_max_order_by
  min: signals_min_order_by
  stddev: signals_stddev_order_by
  stddev_pop: signals_stddev_pop_order_by
  stddev_samp: signals_stddev_samp_order_by
  sum: signals_sum_order_by
  var_pop: signals_var_pop_order_by
  var_samp: signals_var_samp_order_by
  variance: signals_variance_order_by
}

"""
aggregate avg on columns
"""
type signals_avg_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by avg() on columns of table "signal"
"""
input signals_avg_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
Boolean expression to filter rows from the table "signal". All fields are combined with a logical 'AND'.
"""
input signals_bool_exp {
  _and: [signals_bool_exp!]
  _not: signals_bool_exp
  _or: [signals_bool_exp!]
  account: accounts_bool_exp
  account_id: String_comparison_exp
  atom: atoms_bool_exp
  atom_id: numeric_comparison_exp
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  delta: numeric_comparison_exp
  deposit: deposits_bool_exp
  deposit_id: String_comparison_exp
  id: String_comparison_exp
  redemption: redemptions_bool_exp
  redemption_id: String_comparison_exp
  transaction_hash: bytea_comparison_exp
  triple: triples_bool_exp
  triple_id: numeric_comparison_exp
}

input signals_from_following_args {
  address: String
}

"""
aggregate max on columns
"""
type signals_max_fields {
  account_id: String
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  delta: numeric
  deposit_id: String
  id: String
  redemption_id: String
  triple_id: numeric
}

"""
order by max() on columns of table "signal"
"""
input signals_max_order_by {
  account_id: order_by
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  deposit_id: order_by
  id: order_by
  redemption_id: order_by
  triple_id: order_by
}

"""
aggregate min on columns
"""
type signals_min_fields {
  account_id: String
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  delta: numeric
  deposit_id: String
  id: String
  redemption_id: String
  triple_id: numeric
}

"""
order by min() on columns of table "signal"
"""
input signals_min_order_by {
  account_id: order_by
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  deposit_id: order_by
  id: order_by
  redemption_id: order_by
  triple_id: order_by
}

"""
Ordering options when selecting data from "signal".
"""
input signals_order_by {
  account: accounts_order_by
  account_id: order_by
  atom: atoms_order_by
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  deposit: deposits_order_by
  deposit_id: order_by
  id: order_by
  redemption: redemptions_order_by
  redemption_id: order_by
  transaction_hash: order_by
  triple: triples_order_by
  triple_id: order_by
}

"""
select columns of table "signal"
"""
enum signals_select_column {
  """
  column name
  """
  account_id
  """
  column name
  """
  atom_id
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  delta
  """
  column name
  """
  deposit_id
  """
  column name
  """
  id
  """
  column name
  """
  redemption_id
  """
  column name
  """
  transaction_hash
  """
  column name
  """
  triple_id
}

"""
aggregate stddev on columns
"""
type signals_stddev_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by stddev() on columns of table "signal"
"""
input signals_stddev_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type signals_stddev_pop_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by stddev_pop() on columns of table "signal"
"""
input signals_stddev_pop_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type signals_stddev_samp_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by stddev_samp() on columns of table "signal"
"""
input signals_stddev_samp_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
Streaming cursor of the table "signals"
"""
input signals_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: signals_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input signals_stream_cursor_value_input {
  account_id: String
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  delta: numeric
  deposit_id: String
  id: String
  redemption_id: String
  transaction_hash: bytea
  triple_id: numeric
}

"""
aggregate sum on columns
"""
type signals_sum_fields {
  atom_id: numeric
  block_number: numeric
  block_timestamp: bigint
  delta: numeric
  triple_id: numeric
}

"""
order by sum() on columns of table "signal"
"""
input signals_sum_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
aggregate var_pop on columns
"""
type signals_var_pop_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by var_pop() on columns of table "signal"
"""
input signals_var_pop_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
aggregate var_samp on columns
"""
type signals_var_samp_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by var_samp() on columns of table "signal"
"""
input signals_var_samp_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
aggregate variance on columns
"""
type signals_variance_fields {
  atom_id: Float
  block_number: Float
  block_timestamp: Float
  delta: Float
  triple_id: Float
}

"""
order by variance() on columns of table "signal"
"""
input signals_variance_order_by {
  atom_id: order_by
  block_number: order_by
  block_timestamp: order_by
  delta: order_by
  triple_id: order_by
}

"""
columns and relationships of "stats"
"""
type stats {
  contract_balance: numeric
  id: Int!
  total_accounts: Int
  total_atoms: Int
  total_fees: numeric
  total_positions: Int
  total_signals: Int
  total_triples: Int
}

"""
aggregated selection of "stats"
"""
type stats_aggregate {
  aggregate: stats_aggregate_fields
  nodes: [stats!]!
}

"""
aggregate fields of "stats"
"""
type stats_aggregate_fields {
  avg: stats_avg_fields
  count(columns: [stats_select_column!], distinct: Boolean): Int!
  max: stats_max_fields
  min: stats_min_fields
  stddev: stats_stddev_fields
  stddev_pop: stats_stddev_pop_fields
  stddev_samp: stats_stddev_samp_fields
  sum: stats_sum_fields
  var_pop: stats_var_pop_fields
  var_samp: stats_var_samp_fields
  variance: stats_variance_fields
}

"""
aggregate avg on columns
"""
type stats_avg_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

"""
Boolean expression to filter rows from the table "stats". All fields are combined with a logical 'AND'.
"""
input stats_bool_exp {
  _and: [stats_bool_exp!]
  _not: stats_bool_exp
  _or: [stats_bool_exp!]
  contract_balance: numeric_comparison_exp
  id: Int_comparison_exp
  total_accounts: Int_comparison_exp
  total_atoms: Int_comparison_exp
  total_fees: numeric_comparison_exp
  total_positions: Int_comparison_exp
  total_signals: Int_comparison_exp
  total_triples: Int_comparison_exp
}

"""
aggregate max on columns
"""
type stats_max_fields {
  contract_balance: numeric
  id: Int
  total_accounts: Int
  total_atoms: Int
  total_fees: numeric
  total_positions: Int
  total_signals: Int
  total_triples: Int
}

"""
aggregate min on columns
"""
type stats_min_fields {
  contract_balance: numeric
  id: Int
  total_accounts: Int
  total_atoms: Int
  total_fees: numeric
  total_positions: Int
  total_signals: Int
  total_triples: Int
}

"""
Ordering options when selecting data from "stats".
"""
input stats_order_by {
  contract_balance: order_by
  id: order_by
  total_accounts: order_by
  total_atoms: order_by
  total_fees: order_by
  total_positions: order_by
  total_signals: order_by
  total_triples: order_by
}

"""
select columns of table "stats"
"""
enum stats_select_column {
  """
  column name
  """
  contract_balance
  """
  column name
  """
  id
  """
  column name
  """
  total_accounts
  """
  column name
  """
  total_atoms
  """
  column name
  """
  total_fees
  """
  column name
  """
  total_positions
  """
  column name
  """
  total_signals
  """
  column name
  """
  total_triples
}

"""
aggregate stddev on columns
"""
type stats_stddev_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

"""
aggregate stddev_pop on columns
"""
type stats_stddev_pop_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

"""
aggregate stddev_samp on columns
"""
type stats_stddev_samp_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

"""
Streaming cursor of the table "stats"
"""
input stats_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: stats_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input stats_stream_cursor_value_input {
  contract_balance: numeric
  id: Int
  total_accounts: Int
  total_atoms: Int
  total_fees: numeric
  total_positions: Int
  total_signals: Int
  total_triples: Int
}

"""
aggregate sum on columns
"""
type stats_sum_fields {
  contract_balance: numeric
  id: Int
  total_accounts: Int
  total_atoms: Int
  total_fees: numeric
  total_positions: Int
  total_signals: Int
  total_triples: Int
}

"""
aggregate var_pop on columns
"""
type stats_var_pop_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

"""
aggregate var_samp on columns
"""
type stats_var_samp_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

"""
aggregate variance on columns
"""
type stats_variance_fields {
  contract_balance: Float
  id: Float
  total_accounts: Float
  total_atoms: Float
  total_fees: Float
  total_positions: Float
  total_signals: Float
  total_triples: Float
}

type subscription_root {
  """
  fetch data from the table: "account" using primary key columns
  """
  account(id: String!): accounts
  """
  An array relationship
  """
  accounts(
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  An aggregate relationship
  """
  accounts_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  fetch data from the table in a streaming manner: "account"
  """
  accounts_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [accounts_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  execute function "accounts_that_claim_about_account" which returns "account"
  """
  accounts_that_claim_about_account(
    """
    input parameters for function "accounts_that_claim_about_account"
    """
    args: accounts_that_claim_about_account_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  execute function "accounts_that_claim_about_account" and query aggregates on result of table type "account"
  """
  accounts_that_claim_about_account_aggregate(
    """
    input parameters for function "accounts_that_claim_about_account_aggregate"
    """
    args: accounts_that_claim_about_account_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  fetch data from the table: "atom" using primary key columns
  """
  atom(id: numeric!): atoms
  """
  fetch data from the table: "atom_value" using primary key columns
  """
  atom_value(id: numeric!): atom_values
  """
  fetch data from the table: "atom_value"
  """
  atom_values(
    """
    distinct select on columns
    """
    distinct_on: [atom_values_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atom_values_order_by!]
    """
    filter the rows returned
    """
    where: atom_values_bool_exp
  ): [atom_values!]!
  """
  fetch aggregated fields from the table: "atom_value"
  """
  atom_values_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [atom_values_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atom_values_order_by!]
    """
    filter the rows returned
    """
    where: atom_values_bool_exp
  ): atom_values_aggregate!
  """
  fetch data from the table in a streaming manner: "atom_value"
  """
  atom_values_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [atom_values_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: atom_values_bool_exp
  ): [atom_values!]!
  """
  An array relationship
  """
  atoms(
    """
    distinct select on columns
    """
    distinct_on: [atoms_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atoms_order_by!]
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): [atoms!]!
  """
  An aggregate relationship
  """
  atoms_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [atoms_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [atoms_order_by!]
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): atoms_aggregate!
  """
  fetch data from the table in a streaming manner: "atom"
  """
  atoms_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [atoms_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: atoms_bool_exp
  ): [atoms!]!
  """
  fetch data from the table: "book" using primary key columns
  """
  book(id: numeric!): books
  """
  fetch data from the table: "book"
  """
  books(
    """
    distinct select on columns
    """
    distinct_on: [books_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [books_order_by!]
    """
    filter the rows returned
    """
    where: books_bool_exp
  ): [books!]!
  """
  fetch aggregated fields from the table: "book"
  """
  books_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [books_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [books_order_by!]
    """
    filter the rows returned
    """
    where: books_bool_exp
  ): books_aggregate!
  """
  fetch data from the table in a streaming manner: "book"
  """
  books_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [books_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: books_bool_exp
  ): [books!]!
  """
  fetch data from the table: "cached_image" using primary key columns
  """
  cached_image(url: String!): cached_images
  """
  fetch data from the table: "cached_image"
  """
  cached_images(
    """
    distinct select on columns
    """
    distinct_on: [cached_images_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [cached_images_order_by!]
    """
    filter the rows returned
    """
    where: cached_images_bool_exp
  ): [cached_images!]!
  """
  fetch data from the table in a streaming manner: "cached_image"
  """
  cached_images_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [cached_images_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: cached_images_bool_exp
  ): [cached_images!]!
  """
  fetch data from the table: "chainlink_price" using primary key columns
  """
  chainlink_price(id: numeric!): chainlink_prices
  """
  fetch data from the table: "chainlink_price"
  """
  chainlink_prices(
    """
    distinct select on columns
    """
    distinct_on: [chainlink_prices_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [chainlink_prices_order_by!]
    """
    filter the rows returned
    """
    where: chainlink_prices_bool_exp
  ): [chainlink_prices!]!
  """
  fetch data from the table in a streaming manner: "chainlink_price"
  """
  chainlink_prices_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [chainlink_prices_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: chainlink_prices_bool_exp
  ): [chainlink_prices!]!
  """
  fetch data from the table: "claim" using primary key columns
  """
  claim(id: String!): claims
  """
  An array relationship
  """
  claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  execute function "claims_from_following" which returns "claim"
  """
  claims_from_following(
    """
    input parameters for function "claims_from_following"
    """
    args: claims_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  execute function "claims_from_following" and query aggregates on result of table type "claim"
  """
  claims_from_following_aggregate(
    """
    input parameters for function "claims_from_following_aggregate"
    """
    args: claims_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  fetch data from the table in a streaming manner: "claim"
  """
  claims_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [claims_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  fetch data from the table: "deposit" using primary key columns
  """
  deposit(id: String!): deposits
  """
  An array relationship
  """
  deposits(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): [deposits!]!
  """
  An aggregate relationship
  """
  deposits_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): deposits_aggregate!
  """
  fetch data from the table in a streaming manner: "deposit"
  """
  deposits_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [deposits_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): [deposits!]!
  """
  fetch data from the table: "event" using primary key columns
  """
  event(id: String!): events
  """
  An array relationship
  """
  events(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): [events!]!
  """
  An aggregate relationship
  """
  events_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [events_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [events_order_by!]
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): events_aggregate!
  """
  fetch data from the table in a streaming manner: "event"
  """
  events_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [events_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: events_bool_exp
  ): [events!]!
  """
  fetch data from the table: "fee_transfer" using primary key columns
  """
  fee_transfer(id: String!): fee_transfers
  """
  An array relationship
  """
  fee_transfers(
    """
    distinct select on columns
    """
    distinct_on: [fee_transfers_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [fee_transfers_order_by!]
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): [fee_transfers!]!
  """
  An aggregate relationship
  """
  fee_transfers_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [fee_transfers_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [fee_transfers_order_by!]
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): fee_transfers_aggregate!
  """
  fetch data from the table in a streaming manner: "fee_transfer"
  """
  fee_transfers_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [fee_transfers_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: fee_transfers_bool_exp
  ): [fee_transfers!]!
  """
  execute function "following" which returns "account"
  """
  following(
    """
    input parameters for function "following"
    """
    args: following_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): [accounts!]!
  """
  execute function "following" and query aggregates on result of table type "account"
  """
  following_aggregate(
    """
    input parameters for function "following_aggregate"
    """
    args: following_args!
    """
    distinct select on columns
    """
    distinct_on: [accounts_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [accounts_order_by!]
    """
    filter the rows returned
    """
    where: accounts_bool_exp
  ): accounts_aggregate!
  """
  fetch data from the table: "organization" using primary key columns
  """
  organization(id: numeric!): organizations
  """
  fetch data from the table: "organization"
  """
  organizations(
    """
    distinct select on columns
    """
    distinct_on: [organizations_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [organizations_order_by!]
    """
    filter the rows returned
    """
    where: organizations_bool_exp
  ): [organizations!]!
  """
  fetch aggregated fields from the table: "organization"
  """
  organizations_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [organizations_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [organizations_order_by!]
    """
    filter the rows returned
    """
    where: organizations_bool_exp
  ): organizations_aggregate!
  """
  fetch data from the table in a streaming manner: "organization"
  """
  organizations_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [organizations_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: organizations_bool_exp
  ): [organizations!]!
  """
  fetch data from the table: "person" using primary key columns
  """
  person(id: numeric!): persons
  """
  fetch data from the table: "person"
  """
  persons(
    """
    distinct select on columns
    """
    distinct_on: [persons_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [persons_order_by!]
    """
    filter the rows returned
    """
    where: persons_bool_exp
  ): [persons!]!
  """
  fetch aggregated fields from the table: "person"
  """
  persons_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [persons_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [persons_order_by!]
    """
    filter the rows returned
    """
    where: persons_bool_exp
  ): persons_aggregate!
  """
  fetch data from the table in a streaming manner: "person"
  """
  persons_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [persons_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: persons_bool_exp
  ): [persons!]!
  """
  fetch data from the table: "position" using primary key columns
  """
  position(id: String!): positions
  """
  An array relationship
  """
  positions(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): [positions!]!
  """
  An aggregate relationship
  """
  positions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): positions_aggregate!
  """
  fetch data from the table in a streaming manner: "position"
  """
  positions_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [positions_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): [positions!]!
  """
  fetch data from the table: "predicate_object"
  """
  predicate_objects(
    """
    distinct select on columns
    """
    distinct_on: [predicate_objects_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [predicate_objects_order_by!]
    """
    filter the rows returned
    """
    where: predicate_objects_bool_exp
  ): [predicate_objects!]!
  """
  fetch aggregated fields from the table: "predicate_object"
  """
  predicate_objects_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [predicate_objects_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [predicate_objects_order_by!]
    """
    filter the rows returned
    """
    where: predicate_objects_bool_exp
  ): predicate_objects_aggregate!
  """
  fetch data from the table: "predicate_object" using primary key columns
  """
  predicate_objects_by_pk(id: String!): predicate_objects
  """
  fetch data from the table in a streaming manner: "predicate_object"
  """
  predicate_objects_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [predicate_objects_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: predicate_objects_bool_exp
  ): [predicate_objects!]!
  """
  fetch data from the table: "redemption" using primary key columns
  """
  redemption(id: String!): redemptions
  """
  An array relationship
  """
  redemptions(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): [redemptions!]!
  """
  An aggregate relationship
  """
  redemptions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): redemptions_aggregate!
  """
  fetch data from the table in a streaming manner: "redemption"
  """
  redemptions_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [redemptions_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): [redemptions!]!
  """
  fetch data from the table: "signal" using primary key columns
  """
  signal(id: String!): signals
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  """
  execute function "signals_from_following" which returns "signal"
  """
  signals_from_following(
    """
    input parameters for function "signals_from_following"
    """
    args: signals_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  execute function "signals_from_following" and query aggregates on result of table type "signal"
  """
  signals_from_following_aggregate(
    """
    input parameters for function "signals_from_following_aggregate"
    """
    args: signals_from_following_args!
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  """
  fetch data from the table in a streaming manner: "signal"
  """
  signals_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [signals_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  fetch data from the table: "stats" using primary key columns
  """
  stat(id: Int!): stats
  """
  fetch data from the table: "stats"
  """
  stats(
    """
    distinct select on columns
    """
    distinct_on: [stats_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [stats_order_by!]
    """
    filter the rows returned
    """
    where: stats_bool_exp
  ): [stats!]!
  """
  fetch aggregated fields from the table: "stats"
  """
  stats_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [stats_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [stats_order_by!]
    """
    filter the rows returned
    """
    where: stats_bool_exp
  ): stats_aggregate!
  """
  fetch data from the table in a streaming manner: "stats"
  """
  stats_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [stats_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: stats_bool_exp
  ): [stats!]!
  """
  fetch data from the table: "thing" using primary key columns
  """
  thing(id: numeric!): things
  """
  fetch data from the table: "thing"
  """
  things(
    """
    distinct select on columns
    """
    distinct_on: [things_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [things_order_by!]
    """
    filter the rows returned
    """
    where: things_bool_exp
  ): [things!]!
  """
  fetch aggregated fields from the table: "thing"
  """
  things_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [things_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [things_order_by!]
    """
    filter the rows returned
    """
    where: things_bool_exp
  ): things_aggregate!
  """
  fetch data from the table in a streaming manner: "thing"
  """
  things_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [things_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: things_bool_exp
  ): [things!]!
  """
  fetch data from the table: "triple" using primary key columns
  """
  triple(id: numeric!): triples
  """
  An array relationship
  """
  triples(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  An aggregate relationship
  """
  triples_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [triples_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [triples_order_by!]
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): triples_aggregate!
  """
  fetch data from the table in a streaming manner: "triple"
  """
  triples_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [triples_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: triples_bool_exp
  ): [triples!]!
  """
  fetch data from the table: "vault" using primary key columns
  """
  vault(id: numeric!): vaults
  """
  fetch data from the table: "vault"
  """
  vaults(
    """
    distinct select on columns
    """
    distinct_on: [vaults_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [vaults_order_by!]
    """
    filter the rows returned
    """
    where: vaults_bool_exp
  ): [vaults!]!
  """
  fetch aggregated fields from the table: "vault"
  """
  vaults_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [vaults_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [vaults_order_by!]
    """
    filter the rows returned
    """
    where: vaults_bool_exp
  ): vaults_aggregate!
  """
  fetch data from the table in a streaming manner: "vault"
  """
  vaults_stream(
    """
    maximum number of rows returned in a single batch
    """
    batch_size: Int!
    """
    cursor to stream the results returned by the query
    """
    cursor: [vaults_stream_cursor_input]!
    """
    filter the rows returned
    """
    where: vaults_bool_exp
  ): [vaults!]!
}

"""
columns and relationships of "thing"
"""
type things {
  """
  An object relationship
  """
  atom: atoms
  """
  An object relationship
  """
  cached_image: cached_images
  description: String
  id: numeric!
  image: String
  name: String
  url: String
}

"""
aggregated selection of "thing"
"""
type things_aggregate {
  aggregate: things_aggregate_fields
  nodes: [things!]!
}

"""
aggregate fields of "thing"
"""
type things_aggregate_fields {
  avg: things_avg_fields
  count(columns: [things_select_column!], distinct: Boolean): Int!
  max: things_max_fields
  min: things_min_fields
  stddev: things_stddev_fields
  stddev_pop: things_stddev_pop_fields
  stddev_samp: things_stddev_samp_fields
  sum: things_sum_fields
  var_pop: things_var_pop_fields
  var_samp: things_var_samp_fields
  variance: things_variance_fields
}

"""
aggregate avg on columns
"""
type things_avg_fields {
  id: Float
}

"""
Boolean expression to filter rows from the table "thing". All fields are combined with a logical 'AND'.
"""
input things_bool_exp {
  _and: [things_bool_exp!]
  _not: things_bool_exp
  _or: [things_bool_exp!]
  atom: atoms_bool_exp
  cached_image: cached_images_bool_exp
  description: String_comparison_exp
  id: numeric_comparison_exp
  image: String_comparison_exp
  name: String_comparison_exp
  url: String_comparison_exp
}

"""
aggregate max on columns
"""
type things_max_fields {
  description: String
  id: numeric
  image: String
  name: String
  url: String
}

"""
aggregate min on columns
"""
type things_min_fields {
  description: String
  id: numeric
  image: String
  name: String
  url: String
}

"""
Ordering options when selecting data from "thing".
"""
input things_order_by {
  atom: atoms_order_by
  cached_image: cached_images_order_by
  description: order_by
  id: order_by
  image: order_by
  name: order_by
  url: order_by
}

"""
select columns of table "thing"
"""
enum things_select_column {
  """
  column name
  """
  description
  """
  column name
  """
  id
  """
  column name
  """
  image
  """
  column name
  """
  name
  """
  column name
  """
  url
}

"""
aggregate stddev on columns
"""
type things_stddev_fields {
  id: Float
}

"""
aggregate stddev_pop on columns
"""
type things_stddev_pop_fields {
  id: Float
}

"""
aggregate stddev_samp on columns
"""
type things_stddev_samp_fields {
  id: Float
}

"""
Streaming cursor of the table "things"
"""
input things_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: things_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input things_stream_cursor_value_input {
  description: String
  id: numeric
  image: String
  name: String
  url: String
}

"""
aggregate sum on columns
"""
type things_sum_fields {
  id: numeric
}

"""
aggregate var_pop on columns
"""
type things_var_pop_fields {
  id: Float
}

"""
aggregate var_samp on columns
"""
type things_var_samp_fields {
  id: Float
}

"""
aggregate variance on columns
"""
type things_variance_fields {
  id: Float
}

scalar timestamptz

"""
Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'.
"""
input timestamptz_comparison_exp {
  _eq: timestamptz
  _gt: timestamptz
  _gte: timestamptz
  _in: [timestamptz!]
  _is_null: Boolean
  _lt: timestamptz
  _lte: timestamptz
  _neq: timestamptz
  _nin: [timestamptz!]
}

"""
columns and relationships of "triple"
"""
type triples {
  block_number: numeric!
  block_timestamp: bigint!
  """
  An array relationship
  """
  claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  An object relationship
  """
  counter_vault: vaults
  counter_vault_id: numeric!
  """
  An object relationship
  """
  creator: accounts
  creator_id: String!
  id: numeric!
  """
  An object relationship
  """
  object: atoms!
  object_id: numeric!
  """
  An object relationship
  """
  predicate: atoms!
  predicate_id: numeric!
  """
  An array relationship
  """
  signals(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): [signals!]!
  """
  An aggregate relationship
  """
  signals_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [signals_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [signals_order_by!]
    """
    filter the rows returned
    """
    where: signals_bool_exp
  ): signals_aggregate!
  """
  An object relationship
  """
  subject: atoms!
  subject_id: numeric!
  transaction_hash: bytea!
  """
  An object relationship
  """
  vault: vaults
  vault_id: numeric!
}

"""
aggregated selection of "triple"
"""
type triples_aggregate {
  aggregate: triples_aggregate_fields
  nodes: [triples!]!
}

input triples_aggregate_bool_exp {
  count: triples_aggregate_bool_exp_count
}

input triples_aggregate_bool_exp_count {
  arguments: [triples_select_column!]
  distinct: Boolean
  filter: triples_bool_exp
  predicate: Int_comparison_exp!
}

"""
aggregate fields of "triple"
"""
type triples_aggregate_fields {
  avg: triples_avg_fields
  count(columns: [triples_select_column!], distinct: Boolean): Int!
  max: triples_max_fields
  min: triples_min_fields
  stddev: triples_stddev_fields
  stddev_pop: triples_stddev_pop_fields
  stddev_samp: triples_stddev_samp_fields
  sum: triples_sum_fields
  var_pop: triples_var_pop_fields
  var_samp: triples_var_samp_fields
  variance: triples_variance_fields
}

"""
order by aggregate values of table "triple"
"""
input triples_aggregate_order_by {
  avg: triples_avg_order_by
  count: order_by
  max: triples_max_order_by
  min: triples_min_order_by
  stddev: triples_stddev_order_by
  stddev_pop: triples_stddev_pop_order_by
  stddev_samp: triples_stddev_samp_order_by
  sum: triples_sum_order_by
  var_pop: triples_var_pop_order_by
  var_samp: triples_var_samp_order_by
  variance: triples_variance_order_by
}

"""
aggregate avg on columns
"""
type triples_avg_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by avg() on columns of table "triple"
"""
input triples_avg_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
Boolean expression to filter rows from the table "triple". All fields are combined with a logical 'AND'.
"""
input triples_bool_exp {
  _and: [triples_bool_exp!]
  _not: triples_bool_exp
  _or: [triples_bool_exp!]
  block_number: numeric_comparison_exp
  block_timestamp: bigint_comparison_exp
  claims: claims_bool_exp
  claims_aggregate: claims_aggregate_bool_exp
  counter_vault: vaults_bool_exp
  counter_vault_id: numeric_comparison_exp
  creator: accounts_bool_exp
  creator_id: String_comparison_exp
  id: numeric_comparison_exp
  object: atoms_bool_exp
  object_id: numeric_comparison_exp
  predicate: atoms_bool_exp
  predicate_id: numeric_comparison_exp
  signals: signals_bool_exp
  signals_aggregate: signals_aggregate_bool_exp
  subject: atoms_bool_exp
  subject_id: numeric_comparison_exp
  transaction_hash: bytea_comparison_exp
  vault: vaults_bool_exp
  vault_id: numeric_comparison_exp
}

"""
aggregate max on columns
"""
type triples_max_fields {
  block_number: numeric
  block_timestamp: bigint
  counter_vault_id: numeric
  creator_id: String
  id: numeric
  object_id: numeric
  predicate_id: numeric
  subject_id: numeric
  vault_id: numeric
}

"""
order by max() on columns of table "triple"
"""
input triples_max_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  creator_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
aggregate min on columns
"""
type triples_min_fields {
  block_number: numeric
  block_timestamp: bigint
  counter_vault_id: numeric
  creator_id: String
  id: numeric
  object_id: numeric
  predicate_id: numeric
  subject_id: numeric
  vault_id: numeric
}

"""
order by min() on columns of table "triple"
"""
input triples_min_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  creator_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
Ordering options when selecting data from "triple".
"""
input triples_order_by {
  block_number: order_by
  block_timestamp: order_by
  claims_aggregate: claims_aggregate_order_by
  counter_vault: vaults_order_by
  counter_vault_id: order_by
  creator: accounts_order_by
  creator_id: order_by
  id: order_by
  object: atoms_order_by
  object_id: order_by
  predicate: atoms_order_by
  predicate_id: order_by
  signals_aggregate: signals_aggregate_order_by
  subject: atoms_order_by
  subject_id: order_by
  transaction_hash: order_by
  vault: vaults_order_by
  vault_id: order_by
}

"""
select columns of table "triple"
"""
enum triples_select_column {
  """
  column name
  """
  block_number
  """
  column name
  """
  block_timestamp
  """
  column name
  """
  counter_vault_id
  """
  column name
  """
  creator_id
  """
  column name
  """
  id
  """
  column name
  """
  object_id
  """
  column name
  """
  predicate_id
  """
  column name
  """
  subject_id
  """
  column name
  """
  transaction_hash
  """
  column name
  """
  vault_id
}

"""
aggregate stddev on columns
"""
type triples_stddev_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by stddev() on columns of table "triple"
"""
input triples_stddev_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
aggregate stddev_pop on columns
"""
type triples_stddev_pop_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by stddev_pop() on columns of table "triple"
"""
input triples_stddev_pop_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
aggregate stddev_samp on columns
"""
type triples_stddev_samp_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by stddev_samp() on columns of table "triple"
"""
input triples_stddev_samp_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
Streaming cursor of the table "triples"
"""
input triples_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: triples_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input triples_stream_cursor_value_input {
  block_number: numeric
  block_timestamp: bigint
  counter_vault_id: numeric
  creator_id: String
  id: numeric
  object_id: numeric
  predicate_id: numeric
  subject_id: numeric
  transaction_hash: bytea
  vault_id: numeric
}

"""
aggregate sum on columns
"""
type triples_sum_fields {
  block_number: numeric
  block_timestamp: bigint
  counter_vault_id: numeric
  id: numeric
  object_id: numeric
  predicate_id: numeric
  subject_id: numeric
  vault_id: numeric
}

"""
order by sum() on columns of table "triple"
"""
input triples_sum_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
aggregate var_pop on columns
"""
type triples_var_pop_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by var_pop() on columns of table "triple"
"""
input triples_var_pop_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
aggregate var_samp on columns
"""
type triples_var_samp_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by var_samp() on columns of table "triple"
"""
input triples_var_samp_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
aggregate variance on columns
"""
type triples_variance_fields {
  block_number: Float
  block_timestamp: Float
  counter_vault_id: Float
  id: Float
  object_id: Float
  predicate_id: Float
  subject_id: Float
  vault_id: Float
}

"""
order by variance() on columns of table "triple"
"""
input triples_variance_order_by {
  block_number: order_by
  block_timestamp: order_by
  counter_vault_id: order_by
  id: order_by
  object_id: order_by
  predicate_id: order_by
  subject_id: order_by
  vault_id: order_by
}

"""
columns and relationships of "vault"
"""
type vaults {
  """
  An object relationship
  """
  atom: atoms
  atom_id: numeric
  """
  An array relationship
  """
  claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  """
  An array relationship
  """
  counter_claims(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): [claims!]!
  """
  An aggregate relationship
  """
  counter_claims_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [claims_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [claims_order_by!]
    """
    filter the rows returned
    """
    where: claims_bool_exp
  ): claims_aggregate!
  current_share_price: numeric!
  """
  An array relationship
  """
  deposits(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): [deposits!]!
  """
  An aggregate relationship
  """
  deposits_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [deposits_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [deposits_order_by!]
    """
    filter the rows returned
    """
    where: deposits_bool_exp
  ): deposits_aggregate!
  id: numeric!
  position_count: Int!
  """
  An array relationship
  """
  positions(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): [positions!]!
  """
  An aggregate relationship
  """
  positions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [positions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [positions_order_by!]
    """
    filter the rows returned
    """
    where: positions_bool_exp
  ): positions_aggregate!
  """
  An array relationship
  """
  redemptions(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): [redemptions!]!
  """
  An aggregate relationship
  """
  redemptions_aggregate(
    """
    distinct select on columns
    """
    distinct_on: [redemptions_select_column!]
    """
    limit the number of rows returned
    """
    limit: Int
    """
    skip the first n rows. Use only with order_by
    """
    offset: Int
    """
    sort the rows by one or more columns
    """
    order_by: [redemptions_order_by!]
    """
    filter the rows returned
    """
    where: redemptions_bool_exp
  ): redemptions_aggregate!
  total_shares: numeric!
  """
  An object relationship
  """
  triple: triples
  triple_id: numeric
}

"""
aggregated selection of "vault"
"""
type vaults_aggregate {
  aggregate: vaults_aggregate_fields
  nodes: [vaults!]!
}

"""
aggregate fields of "vault"
"""
type vaults_aggregate_fields {
  avg: vaults_avg_fields
  count(columns: [vaults_select_column!], distinct: Boolean): Int!
  max: vaults_max_fields
  min: vaults_min_fields
  stddev: vaults_stddev_fields
  stddev_pop: vaults_stddev_pop_fields
  stddev_samp: vaults_stddev_samp_fields
  sum: vaults_sum_fields
  var_pop: vaults_var_pop_fields
  var_samp: vaults_var_samp_fields
  variance: vaults_variance_fields
}

"""
aggregate avg on columns
"""
type vaults_avg_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}

"""
Boolean expression to filter rows from the table "vault". All fields are combined with a logical 'AND'.
"""
input vaults_bool_exp {
  _and: [vaults_bool_exp!]
  _not: vaults_bool_exp
  _or: [vaults_bool_exp!]
  atom: atoms_bool_exp
  atom_id: numeric_comparison_exp
  claims: claims_bool_exp
  claims_aggregate: claims_aggregate_bool_exp
  counter_claims: claims_bool_exp
  counter_claims_aggregate: claims_aggregate_bool_exp
  current_share_price: numeric_comparison_exp
  deposits: deposits_bool_exp
  deposits_aggregate: deposits_aggregate_bool_exp
  id: numeric_comparison_exp
  position_count: Int_comparison_exp
  positions: positions_bool_exp
  positions_aggregate: positions_aggregate_bool_exp
  redemptions: redemptions_bool_exp
  redemptions_aggregate: redemptions_aggregate_bool_exp
  total_shares: numeric_comparison_exp
  triple: triples_bool_exp
  triple_id: numeric_comparison_exp
}

"""
aggregate max on columns
"""
type vaults_max_fields {
  atom_id: numeric
  current_share_price: numeric
  id: numeric
  position_count: Int
  total_shares: numeric
  triple_id: numeric
}

"""
aggregate min on columns
"""
type vaults_min_fields {
  atom_id: numeric
  current_share_price: numeric
  id: numeric
  position_count: Int
  total_shares: numeric
  triple_id: numeric
}

"""
Ordering options when selecting data from "vault".
"""
input vaults_order_by {
  atom: atoms_order_by
  atom_id: order_by
  claims_aggregate: claims_aggregate_order_by
  counter_claims_aggregate: claims_aggregate_order_by
  current_share_price: order_by
  deposits_aggregate: deposits_aggregate_order_by
  id: order_by
  position_count: order_by
  positions_aggregate: positions_aggregate_order_by
  redemptions_aggregate: redemptions_aggregate_order_by
  total_shares: order_by
  triple: triples_order_by
  triple_id: order_by
}

"""
select columns of table "vault"
"""
enum vaults_select_column {
  """
  column name
  """
  atom_id
  """
  column name
  """
  current_share_price
  """
  column name
  """
  id
  """
  column name
  """
  position_count
  """
  column name
  """
  total_shares
  """
  column name
  """
  triple_id
}

"""
aggregate stddev on columns
"""
type vaults_stddev_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}

"""
aggregate stddev_pop on columns
"""
type vaults_stddev_pop_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}

"""
aggregate stddev_samp on columns
"""
type vaults_stddev_samp_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}

"""
Streaming cursor of the table "vaults"
"""
input vaults_stream_cursor_input {
  """
  Stream column input with initial value
  """
  initial_value: vaults_stream_cursor_value_input!
  """
  cursor ordering
  """
  ordering: cursor_ordering
}

"""
Initial value of the column from where the streaming should start
"""
input vaults_stream_cursor_value_input {
  atom_id: numeric
  current_share_price: numeric
  id: numeric
  position_count: Int
  total_shares: numeric
  triple_id: numeric
}

"""
aggregate sum on columns
"""
type vaults_sum_fields {
  atom_id: numeric
  current_share_price: numeric
  id: numeric
  position_count: Int
  total_shares: numeric
  triple_id: numeric
}

"""
aggregate var_pop on columns
"""
type vaults_var_pop_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}

"""
aggregate var_samp on columns
"""
type vaults_var_samp_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}

"""
aggregate variance on columns
"""
type vaults_variance_fields {
  atom_id: Float
  current_share_price: Float
  id: Float
  position_count: Float
  total_shares: Float
  triple_id: Float
}