indexer-schema.graphql

  lastChangeOn

  """
  column name
  """
  name

  """
  column name
  """
  smithStatus

  """
  column name
  """
  status
}

enum IdentityStatusEnum {
  MEMBER
  NOTMEMBER
  REMOVED
  REVOKED
  UNCONFIRMED
  UNVALIDATED
}

"""
Boolean expression to compare columns of type "IdentityStatusEnum". All fields are combined with logical 'AND'.
"""
input IdentityStatusEnumComparisonExp {
  _eq: IdentityStatusEnum
  _in: [IdentityStatusEnum!]
  _isNull: Boolean
  _neq: IdentityStatusEnum
  _nin: [IdentityStatusEnum!]
}

"""
aggregate stddev on columns
"""
type IdentityStddevFields {
  createdOn: Float
  expireOn: Float
  index: Float
  lastChangeOn: Float
}

"""
aggregate stddevPop on columns
"""
type IdentityStddevPopFields {
  createdOn: Float
  expireOn: Float
  index: Float
  lastChangeOn: Float
}

"""
aggregate stddevSamp on columns
"""
type IdentityStddevSampFields {
  createdOn: Float
  expireOn: Float
  index: Float
  lastChangeOn: Float
}

"""
Streaming cursor of the table "identity"
"""
input IdentityStreamCursorInput {
  """
  Stream column input with initial value
  """
  initialValue: IdentityStreamCursorValueInput!

  """
  cursor ordering
  """
  ordering: CursorOrdering
}

"""
Initial value of the column from where the streaming should start
"""
input IdentityStreamCursorValueInput {
  accountId: String
  createdInId: String
  createdOn: Int
  expireOn: Int
  id: String
  index: Int
  isMember: Boolean
  lastChangeOn: Int
  name: String
  smithStatus: SmithStatusEnum
  status: IdentityStatusEnum
}

"""
aggregate sum on columns
"""
type IdentitySumFields {
  createdOn: Int
  expireOn: Int
  index: Int
  lastChangeOn: Int
}

"""
aggregate varPop on columns
"""
type IdentityVarPopFields {
  createdOn: Float
  expireOn: Float
  index: Float
  lastChangeOn: Float
}

"""
aggregate varSamp on columns
"""
type IdentityVarSampFields {
  createdOn: Float
  expireOn: Float
  index: Float
  lastChangeOn: Float
}

"""
aggregate variance on columns
"""
type IdentityVarianceFields {
  createdOn: Float
  expireOn: Float
  index: Float
  lastChangeOn: Float
}

"""
Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'.
"""
input IntArrayComparisonExp {
  """
  is the array contained in the given array value
  """
  _containedIn: [Int!]

  """
  does the array contain the given value
  """
  _contains: [Int!]
  _eq: [Int!]
  _gt: [Int!]
  _gte: [Int!]
  _in: [[Int!]!]
  _isNull: Boolean
  _lt: [Int!]
  _lte: [Int!]
  _neq: [Int!]
  _nin: [[Int!]!]
}

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

enum ItemTypeEnum {
  CALLS
  EVENTS
  EXTRINSICS
}

"""
Boolean expression to compare columns of type "ItemTypeEnum". All fields are combined with logical 'AND'.
"""
input ItemTypeEnumComparisonExp {
  _eq: ItemTypeEnum
  _in: [ItemTypeEnum!]
  _isNull: Boolean
  _neq: ItemTypeEnum
  _nin: [ItemTypeEnum!]
}

"""
columns and relationships of "items_counter"
"""
type ItemsCounter {
  id: String!
  level: CounterLevelEnum
  total: Int!
  type: ItemTypeEnum
}

"""
aggregated selection of "items_counter"
"""
type ItemsCounterAggregate {
  aggregate: ItemsCounterAggregateFields
  nodes: [ItemsCounter!]!
}

"""
aggregate fields of "items_counter"
"""
type ItemsCounterAggregateFields {
  avg: ItemsCounterAvgFields
  count(columns: [ItemsCounterSelectColumn!], distinct: Boolean): Int!
  max: ItemsCounterMaxFields
  min: ItemsCounterMinFields
  stddev: ItemsCounterStddevFields
  stddevPop: ItemsCounterStddevPopFields
  stddevSamp: ItemsCounterStddevSampFields
  sum: ItemsCounterSumFields
  varPop: ItemsCounterVarPopFields
  varSamp: ItemsCounterVarSampFields
  variance: ItemsCounterVarianceFields
}

"""
aggregate avg on columns
"""
type ItemsCounterAvgFields {
  total: Float
}

"""
Boolean expression to filter rows from the table "items_counter". All fields are combined with a logical 'AND'.
"""
input ItemsCounterBoolExp {
  _and: [ItemsCounterBoolExp!]
  _not: ItemsCounterBoolExp
  _or: [ItemsCounterBoolExp!]
  id: StringComparisonExp
  level: CounterLevelEnumComparisonExp
  total: IntComparisonExp
  type: ItemTypeEnumComparisonExp
}

"""
aggregate max on columns
"""
type ItemsCounterMaxFields {
  id: String
  total: Int
}

"""
aggregate min on columns
"""
type ItemsCounterMinFields {
  id: String
  total: Int
}

"""
Ordering options when selecting data from "items_counter".
"""
input ItemsCounterOrderBy {
  id: OrderBy
  level: OrderBy
  total: OrderBy
  type: OrderBy
}

"""
select columns of table "items_counter"
"""
enum ItemsCounterSelectColumn {
  """
  column name
  """
  id

  """
  column name
  """
  level

  """
  column name
  """
  total

  """
  column name
  """
  type
}

"""
aggregate stddev on columns
"""
type ItemsCounterStddevFields {
  total: Float
}

"""
aggregate stddevPop on columns
"""
type ItemsCounterStddevPopFields {
  total: Float
}

"""
aggregate stddevSamp on columns
"""
type ItemsCounterStddevSampFields {
  total: Float
}

"""
Streaming cursor of the table "items_counter"
"""
input ItemsCounterStreamCursorInput {
  """
  Stream column input with initial value
  """
  initialValue: ItemsCounterStreamCursorValueInput!

  """
  cursor ordering
  """
  ordering: CursorOrdering
}

"""
Initial value of the column from where the streaming should start
"""
input ItemsCounterStreamCursorValueInput {
  id: String
  level: CounterLevelEnum
  total: Int
  type: ItemTypeEnum
}

"""
aggregate sum on columns
"""
type ItemsCounterSumFields {
  total: Int
}

"""
aggregate varPop on columns
"""
type ItemsCounterVarPopFields {
  total: Float
}

"""
aggregate varSamp on columns
"""
type ItemsCounterVarSampFields {
  total: Float
}

"""
aggregate variance on columns
"""
type ItemsCounterVarianceFields {
  total: Float
}

input JsonbCastExp {
  String: StringComparisonExp
}

"""
Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'.
"""
input JsonbComparisonExp {
  _cast: JsonbCastExp

  """
  is the column contained in the given json value
  """
  _containedIn: 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
  """
  _hasKey: String

  """
  do all of these strings exist as top-level keys in the column
  """
  _hasKeysAll: [String!]

  """
  do any of these strings exist as top-level keys in the column
  """
  _hasKeysAny: [String!]
  _in: [jsonb!]
  _isNull: Boolean
  _lt: jsonb
  _lte: jsonb
  _neq: jsonb
  _nin: [jsonb!]
}

"""
columns and relationships of "membership_event"
"""
type MembershipEvent {
  blockNumber: Int!

  """
  An object relationship
  """
  event: Event
  eventId: String
  eventType: EventTypeEnum
  id: String!

  """
  An object relationship
  """
  identity: Identity
  identityId: String
}

"""
aggregated selection of "membership_event"
"""
type MembershipEventAggregate {
  aggregate: MembershipEventAggregateFields
  nodes: [MembershipEvent!]!
}

input MembershipEventAggregateBoolExp {
  count: membershipEventAggregateBoolExpCount
}

"""
aggregate fields of "membership_event"
"""
type MembershipEventAggregateFields {
  avg: MembershipEventAvgFields
  count(columns: [MembershipEventSelectColumn!], distinct: Boolean): Int!
  max: MembershipEventMaxFields
  min: MembershipEventMinFields
  stddev: MembershipEventStddevFields
  stddevPop: MembershipEventStddevPopFields
  stddevSamp: MembershipEventStddevSampFields
  sum: MembershipEventSumFields
  varPop: MembershipEventVarPopFields
  varSamp: MembershipEventVarSampFields
  variance: MembershipEventVarianceFields
}

"""
order by aggregate values of table "membership_event"
"""
input MembershipEventAggregateOrderBy {
  avg: MembershipEventAvgOrderBy
  count: OrderBy
  max: MembershipEventMaxOrderBy
  min: MembershipEventMinOrderBy
  stddev: MembershipEventStddevOrderBy
  stddevPop: MembershipEventStddevPopOrderBy
  stddevSamp: MembershipEventStddevSampOrderBy
  sum: MembershipEventSumOrderBy
  varPop: MembershipEventVarPopOrderBy
  varSamp: MembershipEventVarSampOrderBy
  variance: MembershipEventVarianceOrderBy
}

"""
aggregate avg on columns
"""
type MembershipEventAvgFields {
  blockNumber: Float
}

"""
order by avg() on columns of table "membership_event"
"""
input MembershipEventAvgOrderBy {
  blockNumber: OrderBy
}

"""
Boolean expression to filter rows from the table "membership_event". All fields are combined with a logical 'AND'.
"""
input MembershipEventBoolExp {
  _and: [MembershipEventBoolExp!]
  _not: MembershipEventBoolExp
  _or: [MembershipEventBoolExp!]
  blockNumber: IntComparisonExp
  event: EventBoolExp
  eventId: StringComparisonExp
  eventType: EventTypeEnumComparisonExp
  id: StringComparisonExp
  identity: IdentityBoolExp
  identityId: StringComparisonExp
}

"""
aggregate max on columns
"""
type MembershipEventMaxFields {
  blockNumber: Int
  eventId: String
  id: String
  identityId: String
}

"""
order by max() on columns of table "membership_event"
"""
input MembershipEventMaxOrderBy {
  blockNumber: OrderBy
  eventId: OrderBy
  id: OrderBy
  identityId: OrderBy
}

"""
aggregate min on columns
"""
type MembershipEventMinFields {
  blockNumber: Int
  eventId: String
  id: String
  identityId: String
}

"""
order by min() on columns of table "membership_event"
"""
input MembershipEventMinOrderBy {
  blockNumber: OrderBy
  eventId: OrderBy
  id: OrderBy
  identityId: OrderBy
}

"""
Ordering options when selecting data from "membership_event".
"""
input MembershipEventOrderBy {
  blockNumber: OrderBy
  event: EventOrderBy
  eventId: OrderBy
  eventType: OrderBy
  id: OrderBy
  identity: IdentityOrderBy
  identityId: OrderBy
}

"""
select columns of table "membership_event"
"""
enum MembershipEventSelectColumn {
  """
  column name
  """
  blockNumber

  """
  column name
  """
  eventId

  """
  column name
  """
  eventType

  """
  column name
  """
  id

  """
  column name
  """
  identityId
}

"""
aggregate stddev on columns
"""
type MembershipEventStddevFields {
  blockNumber: Float
}

"""
order by stddev() on columns of table "membership_event"
"""
input MembershipEventStddevOrderBy {
  blockNumber: OrderBy
}

"""
aggregate stddevPop on columns
"""
type MembershipEventStddevPopFields {
  blockNumber: Float
}

"""
order by stddevPop() on columns of table "membership_event"
"""
input MembershipEventStddevPopOrderBy {
  blockNumber: OrderBy
}

"""
aggregate stddevSamp on columns
"""
type MembershipEventStddevSampFields {
  blockNumber: Float
}

"""
order by stddevSamp() on columns of table "membership_event"
"""
input MembershipEventStddevSampOrderBy {
  blockNumber: OrderBy
}

"""
Streaming cursor of the table "membership_event"
"""
input MembershipEventStreamCursorInput {
  """
  Stream column input with initial value
  """
  initialValue: MembershipEventStreamCursorValueInput!

  """
  cursor ordering
  """
  ordering: CursorOrdering
}

"""
Initial value of the column from where the streaming should start
"""
input MembershipEventStreamCursorValueInput {
  blockNumber: Int
  eventId: String
  eventType: EventTypeEnum
  id: String
  identityId: String
}

"""
aggregate sum on columns
"""
type MembershipEventSumFields {
  blockNumber: Int
}

"""
order by sum() on columns of table "membership_event"
"""
input MembershipEventSumOrderBy {
  blockNumber: OrderBy
}

"""
aggregate varPop on columns
"""
type MembershipEventVarPopFields {
  blockNumber: Float
}

"""
order by varPop() on columns of table "membership_event"
"""
input MembershipEventVarPopOrderBy {
  blockNumber: OrderBy
}

"""
aggregate varSamp on columns
"""
type MembershipEventVarSampFields {
  blockNumber: Float
}

"""
order by varSamp() on columns of table "membership_event"
"""
input MembershipEventVarSampOrderBy {
  blockNumber: OrderBy
}

"""
aggregate variance on columns
"""
type MembershipEventVarianceFields {
  blockNumber: Float
}

"""
order by variance() on columns of table "membership_event"
"""
input MembershipEventVarianceOrderBy {
  blockNumber: OrderBy
}

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

"""
column ordering options
"""
enum OrderBy {
  """
  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 "smith_cert"
"""
type SmithCert {
  createdOn: Int!
  id: String!

  """
  An object relationship
  """
  issuer: Identity
  issuerId: String

  """
  An object relationship
  """
  receiver: Identity
  receiverId: String
}

"""
aggregated selection of "smith_cert"
"""
type SmithCertAggregate {
  aggregate: SmithCertAggregateFields
  nodes: [SmithCert!]!
}

input SmithCertAggregateBoolExp {
  count: smithCertAggregateBoolExpCount
}

"""
aggregate fields of "smith_cert"
"""
type SmithCertAggregateFields {
  avg: SmithCertAvgFields
  count(columns: [SmithCertSelectColumn!], distinct: Boolean): Int!
  max: SmithCertMaxFields
  min: SmithCertMinFields
  stddev: SmithCertStddevFields
  stddevPop: SmithCertStddevPopFields
  stddevSamp: SmithCertStddevSampFields
  sum: SmithCertSumFields
  varPop: SmithCertVarPopFields
  varSamp: SmithCertVarSampFields
  variance: SmithCertVarianceFields
}

"""
order by aggregate values of table "smith_cert"
"""
input SmithCertAggregateOrderBy {
  avg: SmithCertAvgOrderBy
  count: OrderBy
  max: SmithCertMaxOrderBy
  min: SmithCertMinOrderBy
  stddev: SmithCertStddevOrderBy
  stddevPop: SmithCertStddevPopOrderBy
  stddevSamp: SmithCertStddevSampOrderBy
  sum: SmithCertSumOrderBy
  varPop: SmithCertVarPopOrderBy
  varSamp: SmithCertVarSampOrderBy
  variance: SmithCertVarianceOrderBy
}

"""
aggregate avg on columns
"""
type SmithCertAvgFields {
  createdOn: Float
}

"""
order by avg() on columns of table "smith_cert"
"""
input SmithCertAvgOrderBy {
  createdOn: OrderBy
}

"""
Boolean expression to filter rows from the table "smith_cert". All fields are combined with a logical 'AND'.
"""
input SmithCertBoolExp {
  _and: [SmithCertBoolExp!]
  _not: SmithCertBoolExp
  _or: [SmithCertBoolExp!]
  createdOn: IntComparisonExp
  id: StringComparisonExp
  issuer: IdentityBoolExp
  issuerId: StringComparisonExp
  receiver: IdentityBoolExp
  receiverId: StringComparisonExp
}

"""
aggregate max on columns
"""
type SmithCertMaxFields {
  createdOn: Int
  id: String
  issuerId: String
  receiverId: String
}

"""
order by max() on columns of table "smith_cert"
"""
input SmithCertMaxOrderBy {
  createdOn: OrderBy
  id: OrderBy
  issuerId: OrderBy
  receiverId: OrderBy
}

"""
aggregate min on columns
"""
type SmithCertMinFields {
  createdOn: Int
  id: String
  issuerId: String
  receiverId: String
}

"""
order by min() on columns of table "smith_cert"
"""
input SmithCertMinOrderBy {
  createdOn: OrderBy
  id: OrderBy
  issuerId: OrderBy
  receiverId: OrderBy
}

"""
Ordering options when selecting data from "smith_cert".
"""
input SmithCertOrderBy {
  createdOn: OrderBy
  id: OrderBy
  issuer: IdentityOrderBy
  issuerId: OrderBy
  receiver: IdentityOrderBy
  receiverId: OrderBy
}

"""
select columns of table "smith_cert"
"""
enum SmithCertSelectColumn {
  """
  column name
  """
  createdOn

  """
  column name
  """
  id

  """
  column name
  """
  issuerId

  """
  column name
  """
  receiverId
}

"""
aggregate stddev on columns
"""
type SmithCertStddevFields {
  createdOn: Float
}

"""
order by stddev() on columns of table "smith_cert"
"""
input SmithCertStddevOrderBy {
  createdOn: OrderBy
}

"""
aggregate stddevPop on columns
"""
type SmithCertStddevPopFields {
  createdOn: Float
}

"""
order by stddevPop() on columns of table "smith_cert"
"""
input SmithCertStddevPopOrderBy {
  createdOn: OrderBy
}

"""
aggregate stddevSamp on columns
"""
type SmithCertStddevSampFields {
  createdOn: Float
}

"""
order by stddevSamp() on columns of table "smith_cert"
"""
input SmithCertStddevSampOrderBy {
  createdOn: OrderBy
}

"""
Streaming cursor of the table "smith_cert"
"""
input SmithCertStreamCursorInput {
  """
  Stream column input with initial value
  """
  initialValue: SmithCertStreamCursorValueInput!

  """
  cursor ordering