schema.graphql

"""The root query type which gives access points into the data universe."""
type Query implements Node {
  """
  Exposes the root query type nested one level down. This is helpful for Relay 1
  which can only query top level fields if they are in a particular form.
  """
  query: Query!

  """
  The root query type must be a `Node` to work well with Relay 1 mutations. This just resolves to `query`.
  """
  nodeId: ID!

  """Fetches an object given its globally unique `ID`."""
  node(
    """The globally unique `ID`."""
    nodeId: ID!
  ): Node

  """Reads a set of `Contract`."""
  contracts(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Contract`."""
    orderBy: [ContractsOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: ContractCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: ContractFilter
  ): [Contract!]

  """Reads a set of `LockToken`."""
  lockTokens(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `LockToken`."""
    orderBy: [LockTokensOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: LockTokenCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: LockTokenFilter
  ): [LockToken!]

  """Reads a set of `Pharo`."""
  pharos(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Pharo`."""
    orderBy: [PharosOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: PharoCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: PharoFilter
  ): [Pharo!]

  """Reads a set of `Price`."""
  prices(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Price`."""
    orderBy: [PricesOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: PriceCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: PriceFilter
  ): [Price!]

  """Reads a set of `Role`."""
  roles(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Role`."""
    orderBy: [RolesOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: RoleCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: RoleFilter
  ): [Role!]

  """Reads a set of `SignedPolicy`."""
  signedPolicies(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `SignedPolicy`."""
    orderBy: [SignedPoliciesOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: SignedPolicyCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: SignedPolicyFilter
  ): [SignedPolicy!]

  """Reads a set of `SignedPosition`."""
  signedPositions(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `SignedPosition`."""
    orderBy: [SignedPositionsOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: SignedPositionCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: SignedPositionFilter
  ): [SignedPosition!]

  """Reads a set of `Subscription`."""
  subscriptions(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Subscription`."""
    orderBy: [SubscriptionsOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: SubscriptionCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: SubscriptionFilter
  ): [Subscription!]

  """Reads a set of `Transfer`."""
  transfers(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Transfer`."""
    orderBy: [TransfersOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: TransferCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: TransferFilter
  ): [Transfer!]

  """Reads a set of `UserReward`."""
  userRewards(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `UserReward`."""
    orderBy: [UserRewardsOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: UserRewardCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: UserRewardFilter
  ): [UserReward!]

  """Reads a set of `UserRole`."""
  userRoles(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `UserRole`."""
    orderBy: [UserRolesOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: UserRoleCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: UserRoleFilter
  ): [UserRole!]

  """Reads a set of `User`."""
  users(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `User`."""
    orderBy: [UsersOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: UserCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: UserFilter
  ): [User!]

  """Reads a set of `Wo`."""
  wos(
    """Only read the first `n` values of the set."""
    first: Int

    """Skip the first `n` values."""
    offset: Int

    """The method to use when ordering `Wo`."""
    orderBy: [WosOrderBy!]

    """
    A condition to be used in determining which values should be returned by the collection.
    """
    condition: WoCondition

    """
    A filter to be used in determining which values should be returned by the collection.
    """
    filter: WoFilter
  ): [Wo!]
  contract(id: String!): Contract
  lockToken(id: String!): LockToken
  pharo(id: String!): Pharo
  price(id: String!): Price
  role(id: String!): Role
  signedPolicy(id: String!): SignedPolicy
  signedPosition(id: String!): SignedPosition
  subscription(id: String!): Subscription
  transfer(id: String!): Transfer
  userReward(id: String!): UserReward
  userRole(id: String!): UserRole
  user(id: String!): User
  wo(id: String!): Wo

  """Reads a single `Contract` using its globally unique `ID`."""
  contractByNodeId(
    """The globally unique `ID` to be used in selecting a single `Contract`."""
    nodeId: ID!
  ): Contract

  """Reads a single `LockToken` using its globally unique `ID`."""
  lockTokenByNodeId(
    """The globally unique `ID` to be used in selecting a single `LockToken`."""
    nodeId: ID!
  ): LockToken

  """Reads a single `Pharo` using its globally unique `ID`."""
  pharoByNodeId(
    """The globally unique `ID` to be used in selecting a single `Pharo`."""
    nodeId: ID!
  ): Pharo

  """Reads a single `Price` using its globally unique `ID`."""
  priceByNodeId(
    """The globally unique `ID` to be used in selecting a single `Price`."""
    nodeId: ID!
  ): Price

  """Reads a single `Role` using its globally unique `ID`."""
  roleByNodeId(
    """The globally unique `ID` to be used in selecting a single `Role`."""
    nodeId: ID!
  ): Role

  """Reads a single `SignedPolicy` using its globally unique `ID`."""
  signedPolicyByNodeId(
    """
    The globally unique `ID` to be used in selecting a single `SignedPolicy`.
    """
    nodeId: ID!
  ): SignedPolicy

  """Reads a single `SignedPosition` using its globally unique `ID`."""
  signedPositionByNodeId(
    """
    The globally unique `ID` to be used in selecting a single `SignedPosition`.
    """
    nodeId: ID!
  ): SignedPosition

  """Reads a single `Subscription` using its globally unique `ID`."""
  subscriptionByNodeId(
    """
    The globally unique `ID` to be used in selecting a single `Subscription`.
    """
    nodeId: ID!
  ): Subscription

  """Reads a single `Transfer` using its globally unique `ID`."""
  transferByNodeId(
    """The globally unique `ID` to be used in selecting a single `Transfer`."""
    nodeId: ID!
  ): Transfer

  """Reads a single `UserReward` using its globally unique `ID`."""
  userRewardByNodeId(
    """
    The globally unique `ID` to be used in selecting a single `UserReward`.
    """
    nodeId: ID!
  ): UserReward

  """Reads a single `UserRole` using its globally unique `ID`."""
  userRoleByNodeId(
    """The globally unique `ID` to be used in selecting a single `UserRole`."""
    nodeId: ID!
  ): UserRole

  """Reads a single `User` using its globally unique `ID`."""
  userByNodeId(
    """The globally unique `ID` to be used in selecting a single `User`."""
    nodeId: ID!
  ): User

  """Reads a single `Wo` using its globally unique `ID`."""
  woByNodeId(
    """The globally unique `ID` to be used in selecting a single `Wo`."""
    nodeId: ID!
  ): Wo
}

"""An object with a globally unique `ID`."""
interface Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
}

type Contract implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  name: String
  address: String
}

"""Methods to use when ordering `Contract`."""
enum ContractsOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  NAME_ASC
  NAME_DESC
  ADDRESS_ASC
  ADDRESS_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Contract` object types. All fields are tested
for equality and combined with a logical ‘and.’
"""
input ContractCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `name` field."""
  name: String

  """Checks for equality with the object’s `address` field."""
  address: String
}

"""
A filter to be used against `Contract` object types. All fields are combined with a logical ‘and.’
"""
input ContractFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `name` field."""
  name: StringFilter

  """Filter by the object’s `address` field."""
  address: StringFilter

  """Checks for all expressions in this list."""
  and: [ContractFilter!]

  """Checks for any expressions in this list."""
  or: [ContractFilter!]

  """Negates the expression."""
  not: ContractFilter
}

"""
A filter to be used against String fields. All fields are combined with a logical ‘and.’
"""
input StringFilter {
  """
  Is null (if `true` is specified) or is not null (if `false` is specified).
  """
  isNull: Boolean

  """Equal to the specified value."""
  equalTo: String

  """Not equal to the specified value."""
  notEqualTo: String

  """Included in the specified list."""
  in: [String!]

  """Not included in the specified list."""
  notIn: [String!]

  """Less than the specified value."""
  lessThan: String

  """Less than or equal to the specified value."""
  lessThanOrEqualTo: String

  """Greater than the specified value."""
  greaterThan: String

  """Greater than or equal to the specified value."""
  greaterThanOrEqualTo: String
}

type LockToken implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  blockNumber: BigFloat
  user: String
  amount: BigFloat
  validity: BigFloat
  claimed: Boolean
}

"""
A floating point number that requires more precision than IEEE 754 binary 64
"""
scalar BigFloat

"""Methods to use when ordering `LockToken`."""
enum LockTokensOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  USER_ASC
  USER_DESC
  AMOUNT_ASC
  AMOUNT_DESC
  VALIDITY_ASC
  VALIDITY_DESC
  CLAIMED_ASC
  CLAIMED_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `LockToken` object types. All fields are tested
for equality and combined with a logical ‘and.’
"""
input LockTokenCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `user` field."""
  user: String

  """Checks for equality with the object’s `amount` field."""
  amount: BigFloat

  """Checks for equality with the object’s `validity` field."""
  validity: BigFloat

  """Checks for equality with the object’s `claimed` field."""
  claimed: Boolean
}

"""
A filter to be used against `LockToken` object types. All fields are combined with a logical ‘and.’
"""
input LockTokenFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `user` field."""
  user: StringFilter

  """Filter by the object’s `amount` field."""
  amount: BigFloatFilter

  """Filter by the object’s `validity` field."""
  validity: BigFloatFilter

  """Filter by the object’s `claimed` field."""
  claimed: BooleanFilter

  """Checks for all expressions in this list."""
  and: [LockTokenFilter!]

  """Checks for any expressions in this list."""
  or: [LockTokenFilter!]

  """Negates the expression."""
  not: LockTokenFilter
}

"""
A filter to be used against BigFloat fields. All fields are combined with a logical ‘and.’
"""
input BigFloatFilter {
  """
  Is null (if `true` is specified) or is not null (if `false` is specified).
  """
  isNull: Boolean

  """Equal to the specified value."""
  equalTo: BigFloat

  """Not equal to the specified value."""
  notEqualTo: BigFloat

  """Included in the specified list."""
  in: [BigFloat!]

  """Not included in the specified list."""
  notIn: [BigFloat!]

  """Less than the specified value."""
  lessThan: BigFloat

  """Less than or equal to the specified value."""
  lessThanOrEqualTo: BigFloat

  """Greater than the specified value."""
  greaterThan: BigFloat

  """Greater than or equal to the specified value."""
  greaterThanOrEqualTo: BigFloat
}

"""
A filter to be used against Boolean fields. All fields are combined with a logical ‘and.’
"""
input BooleanFilter {
  """
  Is null (if `true` is specified) or is not null (if `false` is specified).
  """
  isNull: Boolean

  """Equal to the specified value."""
  equalTo: Boolean

  """Not equal to the specified value."""
  notEqualTo: Boolean

  """Included in the specified list."""
  in: [Boolean!]

  """Not included in the specified list."""
  notIn: [Boolean!]

  """Less than the specified value."""
  lessThan: Boolean

  """Less than or equal to the specified value."""
  lessThanOrEqualTo: Boolean

  """Greater than the specified value."""
  greaterThan: Boolean

  """Greater than or equal to the specified value."""
  greaterThanOrEqualTo: Boolean
}

type Pharo implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  pharoId: BigFloat
  name: String
  description: String
  lifetime: BigFloat
  state: String
  trueEventTime: BigFloat
  birthdate: BigFloat
  blockNumber: BigFloat
  createdAt: BigFloat
}

"""Methods to use when ordering `Pharo`."""
enum PharosOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  PHARO_ID_ASC
  PHARO_ID_DESC
  NAME_ASC
  NAME_DESC
  DESCRIPTION_ASC
  DESCRIPTION_DESC
  LIFETIME_ASC
  LIFETIME_DESC
  STATE_ASC
  STATE_DESC
  TRUE_EVENT_TIME_ASC
  TRUE_EVENT_TIME_DESC
  BIRTHDATE_ASC
  BIRTHDATE_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  CREATED_AT_ASC
  CREATED_AT_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Pharo` object types. All fields are tested for equality and combined with a logical ‘and.’
"""
input PharoCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `pharoId` field."""
  pharoId: BigFloat

  """Checks for equality with the object’s `name` field."""
  name: String

  """Checks for equality with the object’s `description` field."""
  description: String

  """Checks for equality with the object’s `lifetime` field."""
  lifetime: BigFloat

  """Checks for equality with the object’s `state` field."""
  state: String

  """Checks for equality with the object’s `trueEventTime` field."""
  trueEventTime: BigFloat

  """Checks for equality with the object’s `birthdate` field."""
  birthdate: BigFloat

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `createdAt` field."""
  createdAt: BigFloat
}

"""
A filter to be used against `Pharo` object types. All fields are combined with a logical ‘and.’
"""
input PharoFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `pharoId` field."""
  pharoId: BigFloatFilter

  """Filter by the object’s `name` field."""
  name: StringFilter

  """Filter by the object’s `description` field."""
  description: StringFilter

  """Filter by the object’s `lifetime` field."""
  lifetime: BigFloatFilter

  """Filter by the object’s `state` field."""
  state: StringFilter

  """Filter by the object’s `trueEventTime` field."""
  trueEventTime: BigFloatFilter

  """Filter by the object’s `birthdate` field."""
  birthdate: BigFloatFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `createdAt` field."""
  createdAt: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [PharoFilter!]

  """Checks for any expressions in this list."""
  or: [PharoFilter!]

  """Negates the expression."""
  not: PharoFilter
}

type Price implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  chainId: Int
  timestamp: Datetime
  blockNumber: BigFloat
  tokenAddress: String
  price: BigFloat
}

"""
A point in time as described by the [ISO
8601](https://en.wikipedia.org/wiki/ISO_8601) standard. May or may not include a timezone.
"""
scalar Datetime

"""Methods to use when ordering `Price`."""
enum PricesOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  CHAIN_ID_ASC
  CHAIN_ID_DESC
  TIMESTAMP_ASC
  TIMESTAMP_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  TOKEN_ADDRESS_ASC
  TOKEN_ADDRESS_DESC
  PRICE_ASC
  PRICE_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Price` object types. All fields are tested for equality and combined with a logical ‘and.’
"""
input PriceCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `chainId` field."""
  chainId: Int

  """Checks for equality with the object’s `timestamp` field."""
  timestamp: Datetime

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `tokenAddress` field."""
  tokenAddress: String

  """Checks for equality with the object’s `price` field."""
  price: BigFloat
}

"""
A filter to be used against `Price` object types. All fields are combined with a logical ‘and.’
"""
input PriceFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `chainId` field."""
  chainId: IntFilter

  """Filter by the object’s `timestamp` field."""
  timestamp: DatetimeFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `tokenAddress` field."""
  tokenAddress: StringFilter

  """Filter by the object’s `price` field."""
  price: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [PriceFilter!]

  """Checks for any expressions in this list."""
  or: [PriceFilter!]

  """Negates the expression."""
  not: PriceFilter
}

"""
A filter to be used against Int fields. All fields are combined with a logical ‘and.’
"""
input IntFilter {
  """
  Is null (if `true` is specified) or is not null (if `false` is specified).
  """
  isNull: Boolean

  """Equal to the specified value."""
  equalTo: Int

  """Not equal to the specified value."""
  notEqualTo: Int

  """Included in the specified list."""
  in: [Int!]

  """Not included in the specified list."""
  notIn: [Int!]

  """Less than the specified value."""
  lessThan: Int

  """Less than or equal to the specified value."""
  lessThanOrEqualTo: Int

  """Greater than the specified value."""
  greaterThan: Int

  """Greater than or equal to the specified value."""
  greaterThanOrEqualTo: Int
}

"""
A filter to be used against Datetime fields. All fields are combined with a logical ‘and.’
"""
input DatetimeFilter {
  """
  Is null (if `true` is specified) or is not null (if `false` is specified).
  """
  isNull: Boolean

  """Equal to the specified value."""
  equalTo: Datetime

  """Not equal to the specified value."""
  notEqualTo: Datetime

  """Included in the specified list."""
  in: [Datetime!]

  """Not included in the specified list."""
  notIn: [Datetime!]

  """Less than the specified value."""
  lessThan: Datetime

  """Less than or equal to the specified value."""
  lessThanOrEqualTo: Datetime

  """Greater than the specified value."""
  greaterThan: Datetime

  """Greater than or equal to the specified value."""
  greaterThanOrEqualTo: Datetime
}

type Role implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  user: String
  role: String
  createdAt: BigFloat
  updatedAt: BigFloat
}

"""Methods to use when ordering `Role`."""
enum RolesOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  USER_ASC
  USER_DESC
  ROLE_ASC
  ROLE_DESC
  CREATED_AT_ASC
  CREATED_AT_DESC
  UPDATED_AT_ASC
  UPDATED_AT_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Role` object types. All fields are tested for equality and combined with a logical ‘and.’
"""
input RoleCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `user` field."""
  user: String

  """Checks for equality with the object’s `role` field."""
  role: String

  """Checks for equality with the object’s `createdAt` field."""
  createdAt: BigFloat

  """Checks for equality with the object’s `updatedAt` field."""
  updatedAt: BigFloat
}

"""
A filter to be used against `Role` object types. All fields are combined with a logical ‘and.’
"""
input RoleFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `user` field."""
  user: StringFilter

  """Filter by the object’s `role` field."""
  role: StringFilter

  """Filter by the object’s `createdAt` field."""
  createdAt: BigFloatFilter

  """Filter by the object’s `updatedAt` field."""
  updatedAt: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [RoleFilter!]

  """Checks for any expressions in this list."""
  or: [RoleFilter!]

  """Negates the expression."""
  not: RoleFilter
}

type SignedPolicy implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  blockNumber: BigFloat
  minCover: BigFloat
  premium: BigFloat
  rateEstimate: BigFloat
  lengthOfCover: BigFloat
}

"""Methods to use when ordering `SignedPolicy`."""
enum SignedPoliciesOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  MIN_COVER_ASC
  MIN_COVER_DESC
  PREMIUM_ASC
  PREMIUM_DESC
  RATE_ESTIMATE_ASC
  RATE_ESTIMATE_DESC
  LENGTH_OF_COVER_ASC
  LENGTH_OF_COVER_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `SignedPolicy` object types. All fields are
tested for equality and combined with a logical ‘and.’
"""
input SignedPolicyCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `minCover` field."""
  minCover: BigFloat

  """Checks for equality with the object’s `premium` field."""
  premium: BigFloat

  """Checks for equality with the object’s `rateEstimate` field."""
  rateEstimate: BigFloat

  """Checks for equality with the object’s `lengthOfCover` field."""
  lengthOfCover: BigFloat
}

"""
A filter to be used against `SignedPolicy` object types. All fields are combined with a logical ‘and.’
"""
input SignedPolicyFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `minCover` field."""
  minCover: BigFloatFilter

  """Filter by the object’s `premium` field."""
  premium: BigFloatFilter

  """Filter by the object’s `rateEstimate` field."""
  rateEstimate: BigFloatFilter

  """Filter by the object’s `lengthOfCover` field."""
  lengthOfCover: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [SignedPolicyFilter!]

  """Checks for any expressions in this list."""
  or: [SignedPolicyFilter!]

  """Negates the expression."""
  not: SignedPolicyFilter
}

type SignedPosition implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  blockNumber: BigFloat
  maxRisk: BigFloat
  stakeAmount: BigFloat
  rateEstimate: BigFloat
}

"""Methods to use when ordering `SignedPosition`."""
enum SignedPositionsOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  MAX_RISK_ASC
  MAX_RISK_DESC
  STAKE_AMOUNT_ASC
  STAKE_AMOUNT_DESC
  RATE_ESTIMATE_ASC
  RATE_ESTIMATE_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `SignedPosition` object types. All fields are
tested for equality and combined with a logical ‘and.’
"""
input SignedPositionCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `maxRisk` field."""
  maxRisk: BigFloat

  """Checks for equality with the object’s `stakeAmount` field."""
  stakeAmount: BigFloat

  """Checks for equality with the object’s `rateEstimate` field."""
  rateEstimate: BigFloat
}

"""
A filter to be used against `SignedPosition` object types. All fields are combined with a logical ‘and.’
"""
input SignedPositionFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `maxRisk` field."""
  maxRisk: BigFloatFilter

  """Filter by the object’s `stakeAmount` field."""
  stakeAmount: BigFloatFilter

  """Filter by the object’s `rateEstimate` field."""
  rateEstimate: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [SignedPositionFilter!]

  """Checks for any expressions in this list."""
  or: [SignedPositionFilter!]

  """Negates the expression."""
  not: SignedPositionFilter
}

type Subscription implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  chainId: Int
  contractName: String
  contractAddress: String
  fromBlock: BigInt
  toBlock: String
  indexedToBlock: BigInt
  indexedToLogIndex: Int
  createdAt: Datetime!
  updatedAt: Datetime!
}

"""
A signed eight-byte integer. The upper big integer values are greater than the
max value for a JavaScript number. Therefore all big integers will be output as
strings and not numbers.
"""
scalar BigInt

"""Methods to use when ordering `Subscription`."""
enum SubscriptionsOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  CHAIN_ID_ASC
  CHAIN_ID_DESC
  CONTRACT_NAME_ASC
  CONTRACT_NAME_DESC
  CONTRACT_ADDRESS_ASC
  CONTRACT_ADDRESS_DESC
  FROM_BLOCK_ASC
  FROM_BLOCK_DESC
  TO_BLOCK_ASC
  TO_BLOCK_DESC
  INDEXED_TO_BLOCK_ASC
  INDEXED_TO_BLOCK_DESC
  INDEXED_TO_LOG_INDEX_ASC
  INDEXED_TO_LOG_INDEX_DESC
  CREATED_AT_ASC
  CREATED_AT_DESC
  UPDATED_AT_ASC
  UPDATED_AT_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Subscription` object types. All fields are
tested for equality and combined with a logical ‘and.’
"""
input SubscriptionCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `chainId` field."""
  chainId: Int

  """Checks for equality with the object’s `contractName` field."""
  contractName: String

  """Checks for equality with the object’s `contractAddress` field."""
  contractAddress: String

  """Checks for equality with the object’s `fromBlock` field."""
  fromBlock: BigInt

  """Checks for equality with the object’s `toBlock` field."""
  toBlock: String

  """Checks for equality with the object’s `indexedToBlock` field."""
  indexedToBlock: BigInt

  """Checks for equality with the object’s `indexedToLogIndex` field."""
  indexedToLogIndex: Int

  """Checks for equality with the object’s `createdAt` field."""
  createdAt: Datetime

  """Checks for equality with the object’s `updatedAt` field."""
  updatedAt: Datetime
}

"""
A filter to be used against `Subscription` object types. All fields are combined with a logical ‘and.’
"""
input SubscriptionFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `chainId` field."""
  chainId: IntFilter

  """Filter by the object’s `contractName` field."""
  contractName: StringFilter

  """Filter by the object’s `contractAddress` field."""
  contractAddress: StringFilter

  """Filter by the object’s `fromBlock` field."""
  fromBlock: BigIntFilter

  """Filter by the object’s `toBlock` field."""
  toBlock: StringFilter

  """Filter by the object’s `indexedToBlock` field."""
  indexedToBlock: BigIntFilter

  """Filter by the object’s `indexedToLogIndex` field."""
  indexedToLogIndex: IntFilter

  """Filter by the object’s `createdAt` field."""
  createdAt: DatetimeFilter

  """Filter by the object’s `updatedAt` field."""
  updatedAt: DatetimeFilter

  """Checks for all expressions in this list."""
  and: [SubscriptionFilter!]

  """Checks for any expressions in this list."""
  or: [SubscriptionFilter!]

  """Negates the expression."""
  not: SubscriptionFilter
}

"""
A filter to be used against BigInt fields. All fields are combined with a logical ‘and.’
"""
input BigIntFilter {
  """
  Is null (if `true` is specified) or is not null (if `false` is specified).
  """
  isNull: Boolean

  """Equal to the specified value."""
  equalTo: BigInt

  """Not equal to the specified value."""
  notEqualTo: BigInt

  """Included in the specified list."""
  in: [BigInt!]

  """Not included in the specified list."""
  notIn: [BigInt!]

  """Less than the specified value."""
  lessThan: BigInt

  """Less than or equal to the specified value."""
  lessThanOrEqualTo: BigInt

  """Greater than the specified value."""
  greaterThan: BigInt

  """Greater than or equal to the specified value."""
  greaterThanOrEqualTo: BigInt
}

type Transfer implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  from: String
  to: String
  amount: BigFloat
  transferedAt: BigFloat
  blockNumber: BigFloat
}

"""Methods to use when ordering `Transfer`."""
enum TransfersOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  FROM_ASC
  FROM_DESC
  TO_ASC
  TO_DESC
  AMOUNT_ASC
  AMOUNT_DESC
  TRANSFERED_AT_ASC
  TRANSFERED_AT_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Transfer` object types. All fields are tested
for equality and combined with a logical ‘and.’
"""
input TransferCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `from` field."""
  from: String

  """Checks for equality with the object’s `to` field."""
  to: String

  """Checks for equality with the object’s `amount` field."""
  amount: BigFloat

  """Checks for equality with the object’s `transferedAt` field."""
  transferedAt: BigFloat

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat
}

"""
A filter to be used against `Transfer` object types. All fields are combined with a logical ‘and.’
"""
input TransferFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `from` field."""
  from: StringFilter

  """Filter by the object’s `to` field."""
  to: StringFilter

  """Filter by the object’s `amount` field."""
  amount: BigFloatFilter

  """Filter by the object’s `transferedAt` field."""
  transferedAt: BigFloatFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [TransferFilter!]

  """Checks for any expressions in this list."""
  or: [TransferFilter!]

  """Negates the expression."""
  not: TransferFilter
}

type UserReward implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  chainId: Int
  timestamp: BigFloat
  blockNumber: BigFloat
  user: String
  reward: BigFloat
}

"""Methods to use when ordering `UserReward`."""
enum UserRewardsOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  CHAIN_ID_ASC
  CHAIN_ID_DESC
  TIMESTAMP_ASC
  TIMESTAMP_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  USER_ASC
  USER_DESC
  REWARD_ASC
  REWARD_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `UserReward` object types. All fields are tested
for equality and combined with a logical ‘and.’
"""
input UserRewardCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `chainId` field."""
  chainId: Int

  """Checks for equality with the object’s `timestamp` field."""
  timestamp: BigFloat

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `user` field."""
  user: String

  """Checks for equality with the object’s `reward` field."""
  reward: BigFloat
}

"""
A filter to be used against `UserReward` object types. All fields are combined with a logical ‘and.’
"""
input UserRewardFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `chainId` field."""
  chainId: IntFilter

  """Filter by the object’s `timestamp` field."""
  timestamp: BigFloatFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `user` field."""
  user: StringFilter

  """Filter by the object’s `reward` field."""
  reward: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [UserRewardFilter!]

  """Checks for any expressions in this list."""
  or: [UserRewardFilter!]

  """Negates the expression."""
  not: UserRewardFilter
}

type UserRole implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  userId: String
  roleId: String
}

"""Methods to use when ordering `UserRole`."""
enum UserRolesOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  USER_ID_ASC
  USER_ID_DESC
  ROLE_ID_ASC
  ROLE_ID_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `UserRole` object types. All fields are tested
for equality and combined with a logical ‘and.’
"""
input UserRoleCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `userId` field."""
  userId: String

  """Checks for equality with the object’s `roleId` field."""
  roleId: String
}

"""
A filter to be used against `UserRole` object types. All fields are combined with a logical ‘and.’
"""
input UserRoleFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `userId` field."""
  userId: StringFilter

  """Filter by the object’s `roleId` field."""
  roleId: StringFilter

  """Checks for all expressions in this list."""
  and: [UserRoleFilter!]

  """Checks for any expressions in this list."""
  or: [UserRoleFilter!]

  """Negates the expression."""
  not: UserRoleFilter
}

type User implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  address: String
  name: String
  email: String
  userRole: String
  createdAt: BigFloat
  updatedAt: BigFloat
}

"""Methods to use when ordering `User`."""
enum UsersOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  ADDRESS_ASC
  ADDRESS_DESC
  NAME_ASC
  NAME_DESC
  EMAIL_ASC
  EMAIL_DESC
  USER_ROLE_ASC
  USER_ROLE_DESC
  CREATED_AT_ASC
  CREATED_AT_DESC
  UPDATED_AT_ASC
  UPDATED_AT_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `User` object types. All fields are tested for equality and combined with a logical ‘and.’
"""
input UserCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `address` field."""
  address: String

  """Checks for equality with the object’s `name` field."""
  name: String

  """Checks for equality with the object’s `email` field."""
  email: String

  """Checks for equality with the object’s `userRole` field."""
  userRole: String

  """Checks for equality with the object’s `createdAt` field."""
  createdAt: BigFloat

  """Checks for equality with the object’s `updatedAt` field."""
  updatedAt: BigFloat
}

"""
A filter to be used against `User` object types. All fields are combined with a logical ‘and.’
"""
input UserFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `address` field."""
  address: StringFilter

  """Filter by the object’s `name` field."""
  name: StringFilter

  """Filter by the object’s `email` field."""
  email: StringFilter

  """Filter by the object’s `userRole` field."""
  userRole: StringFilter

  """Filter by the object’s `createdAt` field."""
  createdAt: BigFloatFilter

  """Filter by the object’s `updatedAt` field."""
  updatedAt: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [UserFilter!]

  """Checks for any expressions in this list."""
  or: [UserFilter!]

  """Negates the expression."""
  not: UserFilter
}

type Wo implements Node {
  """
  A globally unique identifier. Can be used in various places throughout the system to identify this single value.
  """
  nodeId: ID!
  id: String!
  blockNumber: BigFloat
  pharoId: BigFloat
  alpha: BigFloat
  beta: BigFloat
  rateProbable: BigFloat
  minConfidence: BigFloat
  maxConfidence: BigFloat
  gof: BigFloat
  gammaX: BigFloat
  gammaY: BigFloat
}

"""Methods to use when ordering `Wo`."""
enum WosOrderBy {
  NATURAL
  ID_ASC
  ID_DESC
  BLOCK_NUMBER_ASC
  BLOCK_NUMBER_DESC
  PHARO_ID_ASC
  PHARO_ID_DESC
  ALPHA_ASC
  ALPHA_DESC
  BETA_ASC
  BETA_DESC
  RATE_PROBABLE_ASC
  RATE_PROBABLE_DESC
  MIN_CONFIDENCE_ASC
  MIN_CONFIDENCE_DESC
  MAX_CONFIDENCE_ASC
  MAX_CONFIDENCE_DESC
  GOF_ASC
  GOF_DESC
  GAMMA_X_ASC
  GAMMA_X_DESC
  GAMMA_Y_ASC
  GAMMA_Y_DESC
  PRIMARY_KEY_ASC
  PRIMARY_KEY_DESC
}

"""
A condition to be used against `Wo` object types. All fields are tested for equality and combined with a logical ‘and.’
"""
input WoCondition {
  """Checks for equality with the object’s `id` field."""
  id: String

  """Checks for equality with the object’s `blockNumber` field."""
  blockNumber: BigFloat

  """Checks for equality with the object’s `pharoId` field."""
  pharoId: BigFloat

  """Checks for equality with the object’s `alpha` field."""
  alpha: BigFloat

  """Checks for equality with the object’s `beta` field."""
  beta: BigFloat

  """Checks for equality with the object’s `rateProbable` field."""
  rateProbable: BigFloat

  """Checks for equality with the object’s `minConfidence` field."""
  minConfidence: BigFloat

  """Checks for equality with the object’s `maxConfidence` field."""
  maxConfidence: BigFloat

  """Checks for equality with the object’s `gof` field."""
  gof: BigFloat

  """Checks for equality with the object’s `gammaX` field."""
  gammaX: BigFloat

  """Checks for equality with the object’s `gammaY` field."""
  gammaY: BigFloat
}

"""
A filter to be used against `Wo` object types. All fields are combined with a logical ‘and.’
"""
input WoFilter {
  """Filter by the object’s `id` field."""
  id: StringFilter

  """Filter by the object’s `blockNumber` field."""
  blockNumber: BigFloatFilter

  """Filter by the object’s `pharoId` field."""
  pharoId: BigFloatFilter

  """Filter by the object’s `alpha` field."""
  alpha: BigFloatFilter

  """Filter by the object’s `beta` field."""
  beta: BigFloatFilter

  """Filter by the object’s `rateProbable` field."""
  rateProbable: BigFloatFilter

  """Filter by the object’s `minConfidence` field."""
  minConfidence: BigFloatFilter

  """Filter by the object’s `maxConfidence` field."""
  maxConfidence: BigFloatFilter

  """Filter by the object’s `gof` field."""
  gof: BigFloatFilter

  """Filter by the object’s `gammaX` field."""
  gammaX: BigFloatFilter

  """Filter by the object’s `gammaY` field."""
  gammaY: BigFloatFilter

  """Checks for all expressions in this list."""
  and: [WoFilter!]

  """Checks for any expressions in this list."""
  or: [WoFilter!]

  """Negates the expression."""
  not: WoFilter
}