9017 lines
149 KiB
GraphQL
9017 lines
149 KiB
GraphQL
schema {
|
|
query: query_root
|
|
subscription: subscription_root
|
|
}
|
|
|
|
"""
|
|
whether this query should be cached (Hasura Cloud only)
|
|
"""
|
|
directive @cached(
|
|
"""
|
|
measured in seconds
|
|
"""
|
|
ttl: Int! = 60
|
|
|
|
"""
|
|
refresh the cache entry
|
|
"""
|
|
refresh: Boolean! = false
|
|
) on QUERY
|
|
|
|
"""
|
|
columns and relationships of "account"
|
|
"""
|
|
type Account {
|
|
id: String!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
identity: Identity
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
linkedIdentity: Identity
|
|
linkedIdentityId: String
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
transfersIssued(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): [Transfer!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
transfersIssuedAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): TransferAggregate!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
transfersReceived(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): [Transfer!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
transfersReceivedAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): TransferAggregate!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
wasIdentity(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): [ChangeOwnerKey!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
wasIdentityAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): ChangeOwnerKeyAggregate!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "account"
|
|
"""
|
|
type AccountAggregate {
|
|
aggregate: AccountAggregateFields
|
|
nodes: [Account!]!
|
|
}
|
|
|
|
input AccountAggregateBoolExp {
|
|
count: accountAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "account"
|
|
"""
|
|
type AccountAggregateFields {
|
|
count(columns: [AccountSelectColumn!], distinct: Boolean): Int!
|
|
max: AccountMaxFields
|
|
min: AccountMinFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "account"
|
|
"""
|
|
input AccountAggregateOrderBy {
|
|
count: OrderBy
|
|
max: AccountMaxOrderBy
|
|
min: AccountMinOrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "account". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input AccountBoolExp {
|
|
_and: [AccountBoolExp!]
|
|
_not: AccountBoolExp
|
|
_or: [AccountBoolExp!]
|
|
id: StringComparisonExp
|
|
identity: IdentityBoolExp
|
|
linkedIdentity: IdentityBoolExp
|
|
linkedIdentityId: StringComparisonExp
|
|
transfersIssued: TransferBoolExp
|
|
transfersIssuedAggregate: TransferAggregateBoolExp
|
|
transfersReceived: TransferBoolExp
|
|
transfersReceivedAggregate: TransferAggregateBoolExp
|
|
wasIdentity: ChangeOwnerKeyBoolExp
|
|
wasIdentityAggregate: ChangeOwnerKeyAggregateBoolExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type AccountMaxFields {
|
|
id: String
|
|
linkedIdentityId: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "account"
|
|
"""
|
|
input AccountMaxOrderBy {
|
|
id: OrderBy
|
|
linkedIdentityId: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type AccountMinFields {
|
|
id: String
|
|
linkedIdentityId: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "account"
|
|
"""
|
|
input AccountMinOrderBy {
|
|
id: OrderBy
|
|
linkedIdentityId: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "account".
|
|
"""
|
|
input AccountOrderBy {
|
|
id: OrderBy
|
|
identity: IdentityOrderBy
|
|
linkedIdentity: IdentityOrderBy
|
|
linkedIdentityId: OrderBy
|
|
transfersIssuedAggregate: TransferAggregateOrderBy
|
|
transfersReceivedAggregate: TransferAggregateOrderBy
|
|
wasIdentityAggregate: ChangeOwnerKeyAggregateOrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "account"
|
|
"""
|
|
enum AccountSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
linkedIdentityId
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "account"
|
|
"""
|
|
input AccountStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: AccountStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input AccountStreamCursorValueInput {
|
|
id: String
|
|
linkedIdentityId: String
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "block"
|
|
"""
|
|
type Block {
|
|
"""
|
|
An array relationship
|
|
"""
|
|
calls(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): [Call!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
callsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): CallAggregate!
|
|
callsCount: Int!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
events(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): [Event!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
eventsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): EventAggregate!
|
|
eventsCount: Int!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
extrinsics(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ExtrinsicSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ExtrinsicOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): [Extrinsic!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
extrinsicsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ExtrinsicSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ExtrinsicOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): ExtrinsicAggregate!
|
|
extrinsicsCount: Int!
|
|
extrinsicsicRoot: bytea!
|
|
hash: bytea!
|
|
height: Int!
|
|
id: String!
|
|
implName: String!
|
|
implVersion: Int!
|
|
parentHash: bytea!
|
|
specName: String!
|
|
specVersion: Int!
|
|
stateRoot: bytea!
|
|
timestamp: timestamptz!
|
|
validator: bytea
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "block"
|
|
"""
|
|
type BlockAggregate {
|
|
aggregate: BlockAggregateFields
|
|
nodes: [Block!]!
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "block"
|
|
"""
|
|
type BlockAggregateFields {
|
|
avg: BlockAvgFields
|
|
count(columns: [BlockSelectColumn!], distinct: Boolean): Int!
|
|
max: BlockMaxFields
|
|
min: BlockMinFields
|
|
stddev: BlockStddevFields
|
|
stddevPop: BlockStddevPopFields
|
|
stddevSamp: BlockStddevSampFields
|
|
sum: BlockSumFields
|
|
varPop: BlockVarPopFields
|
|
varSamp: BlockVarSampFields
|
|
variance: BlockVarianceFields
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type BlockAvgFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "block". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input BlockBoolExp {
|
|
_and: [BlockBoolExp!]
|
|
_not: BlockBoolExp
|
|
_or: [BlockBoolExp!]
|
|
calls: CallBoolExp
|
|
callsAggregate: CallAggregateBoolExp
|
|
callsCount: IntComparisonExp
|
|
events: EventBoolExp
|
|
eventsAggregate: EventAggregateBoolExp
|
|
eventsCount: IntComparisonExp
|
|
extrinsics: ExtrinsicBoolExp
|
|
extrinsicsAggregate: ExtrinsicAggregateBoolExp
|
|
extrinsicsCount: IntComparisonExp
|
|
extrinsicsicRoot: ByteaComparisonExp
|
|
hash: ByteaComparisonExp
|
|
height: IntComparisonExp
|
|
id: StringComparisonExp
|
|
implName: StringComparisonExp
|
|
implVersion: IntComparisonExp
|
|
parentHash: ByteaComparisonExp
|
|
specName: StringComparisonExp
|
|
specVersion: IntComparisonExp
|
|
stateRoot: ByteaComparisonExp
|
|
timestamp: TimestamptzComparisonExp
|
|
validator: ByteaComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type BlockMaxFields {
|
|
callsCount: Int
|
|
eventsCount: Int
|
|
extrinsicsCount: Int
|
|
height: Int
|
|
id: String
|
|
implName: String
|
|
implVersion: Int
|
|
specName: String
|
|
specVersion: Int
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type BlockMinFields {
|
|
callsCount: Int
|
|
eventsCount: Int
|
|
extrinsicsCount: Int
|
|
height: Int
|
|
id: String
|
|
implName: String
|
|
implVersion: Int
|
|
specName: String
|
|
specVersion: Int
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "block".
|
|
"""
|
|
input BlockOrderBy {
|
|
callsAggregate: CallAggregateOrderBy
|
|
callsCount: OrderBy
|
|
eventsAggregate: EventAggregateOrderBy
|
|
eventsCount: OrderBy
|
|
extrinsicsAggregate: ExtrinsicAggregateOrderBy
|
|
extrinsicsCount: OrderBy
|
|
extrinsicsicRoot: OrderBy
|
|
hash: OrderBy
|
|
height: OrderBy
|
|
id: OrderBy
|
|
implName: OrderBy
|
|
implVersion: OrderBy
|
|
parentHash: OrderBy
|
|
specName: OrderBy
|
|
specVersion: OrderBy
|
|
stateRoot: OrderBy
|
|
timestamp: OrderBy
|
|
validator: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "block"
|
|
"""
|
|
enum BlockSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
callsCount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
eventsCount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
extrinsicsCount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
extrinsicsicRoot
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
hash
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
height
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
implName
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
implVersion
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
parentHash
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
specName
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
specVersion
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
stateRoot
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
timestamp
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
validator
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type BlockStddevFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type BlockStddevPopFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type BlockStddevSampFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "block"
|
|
"""
|
|
input BlockStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: BlockStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input BlockStreamCursorValueInput {
|
|
callsCount: Int
|
|
eventsCount: Int
|
|
extrinsicsCount: Int
|
|
extrinsicsicRoot: bytea
|
|
hash: bytea
|
|
height: Int
|
|
id: String
|
|
implName: String
|
|
implVersion: Int
|
|
parentHash: bytea
|
|
specName: String
|
|
specVersion: Int
|
|
stateRoot: bytea
|
|
timestamp: timestamptz
|
|
validator: bytea
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type BlockSumFields {
|
|
callsCount: Int
|
|
eventsCount: Int
|
|
extrinsicsCount: Int
|
|
height: Int
|
|
implVersion: Int
|
|
specVersion: Int
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type BlockVarPopFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type BlockVarSampFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type BlockVarianceFields {
|
|
callsCount: Float
|
|
eventsCount: Float
|
|
extrinsicsCount: Float
|
|
height: Float
|
|
implVersion: Float
|
|
specVersion: Float
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'.
|
|
"""
|
|
input BooleanComparisonExp {
|
|
_eq: Boolean
|
|
_gt: Boolean
|
|
_gte: Boolean
|
|
_in: [Boolean!]
|
|
_isNull: Boolean
|
|
_lt: Boolean
|
|
_lte: Boolean
|
|
_neq: Boolean
|
|
_nin: [Boolean!]
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "bytea". All fields are combined with logical 'AND'.
|
|
"""
|
|
input ByteaComparisonExp {
|
|
_eq: bytea
|
|
_gt: bytea
|
|
_gte: bytea
|
|
_in: [bytea!]
|
|
_isNull: Boolean
|
|
_lt: bytea
|
|
_lte: bytea
|
|
_neq: bytea
|
|
_nin: [bytea!]
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "call"
|
|
"""
|
|
type Call {
|
|
address: [Int!]!
|
|
args(
|
|
"""
|
|
JSON select path
|
|
"""
|
|
path: String
|
|
): jsonb
|
|
argsStr: [String!]
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
block: Block
|
|
blockId: String
|
|
error(
|
|
"""
|
|
JSON select path
|
|
"""
|
|
path: String
|
|
): jsonb
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
events(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): [Event!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
eventsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): EventAggregate!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
extrinsic: Extrinsic
|
|
extrinsicId: String
|
|
id: String!
|
|
name: String!
|
|
pallet: String!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
parent: Call
|
|
parentId: String
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
subcalls(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): [Call!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
subcallsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): CallAggregate!
|
|
success: Boolean!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "call"
|
|
"""
|
|
type CallAggregate {
|
|
aggregate: CallAggregateFields
|
|
nodes: [Call!]!
|
|
}
|
|
|
|
input CallAggregateBoolExp {
|
|
bool_and: callAggregateBoolExpBool_and
|
|
bool_or: callAggregateBoolExpBool_or
|
|
count: callAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "call"
|
|
"""
|
|
type CallAggregateFields {
|
|
count(columns: [CallSelectColumn!], distinct: Boolean): Int!
|
|
max: CallMaxFields
|
|
min: CallMinFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "call"
|
|
"""
|
|
input CallAggregateOrderBy {
|
|
count: OrderBy
|
|
max: CallMaxOrderBy
|
|
min: CallMinOrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "call". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input CallBoolExp {
|
|
_and: [CallBoolExp!]
|
|
_not: CallBoolExp
|
|
_or: [CallBoolExp!]
|
|
address: IntArrayComparisonExp
|
|
args: JsonbComparisonExp
|
|
argsStr: StringArrayComparisonExp
|
|
block: BlockBoolExp
|
|
blockId: StringComparisonExp
|
|
error: JsonbComparisonExp
|
|
events: EventBoolExp
|
|
eventsAggregate: EventAggregateBoolExp
|
|
extrinsic: ExtrinsicBoolExp
|
|
extrinsicId: StringComparisonExp
|
|
id: StringComparisonExp
|
|
name: StringComparisonExp
|
|
pallet: StringComparisonExp
|
|
parent: CallBoolExp
|
|
parentId: StringComparisonExp
|
|
subcalls: CallBoolExp
|
|
subcallsAggregate: CallAggregateBoolExp
|
|
success: BooleanComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type CallMaxFields {
|
|
address: [Int!]
|
|
argsStr: [String!]
|
|
blockId: String
|
|
extrinsicId: String
|
|
id: String
|
|
name: String
|
|
pallet: String
|
|
parentId: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "call"
|
|
"""
|
|
input CallMaxOrderBy {
|
|
address: OrderBy
|
|
argsStr: OrderBy
|
|
blockId: OrderBy
|
|
extrinsicId: OrderBy
|
|
id: OrderBy
|
|
name: OrderBy
|
|
pallet: OrderBy
|
|
parentId: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type CallMinFields {
|
|
address: [Int!]
|
|
argsStr: [String!]
|
|
blockId: String
|
|
extrinsicId: String
|
|
id: String
|
|
name: String
|
|
pallet: String
|
|
parentId: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "call"
|
|
"""
|
|
input CallMinOrderBy {
|
|
address: OrderBy
|
|
argsStr: OrderBy
|
|
blockId: OrderBy
|
|
extrinsicId: OrderBy
|
|
id: OrderBy
|
|
name: OrderBy
|
|
pallet: OrderBy
|
|
parentId: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "call".
|
|
"""
|
|
input CallOrderBy {
|
|
address: OrderBy
|
|
args: OrderBy
|
|
argsStr: OrderBy
|
|
block: BlockOrderBy
|
|
blockId: OrderBy
|
|
error: OrderBy
|
|
eventsAggregate: EventAggregateOrderBy
|
|
extrinsic: ExtrinsicOrderBy
|
|
extrinsicId: OrderBy
|
|
id: OrderBy
|
|
name: OrderBy
|
|
pallet: OrderBy
|
|
parent: CallOrderBy
|
|
parentId: OrderBy
|
|
subcallsAggregate: CallAggregateOrderBy
|
|
success: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "call"
|
|
"""
|
|
enum CallSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
address
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
args
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
argsStr
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
blockId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
error
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
extrinsicId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
name
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
pallet
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
parentId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
success
|
|
}
|
|
|
|
"""
|
|
select "callAggregateBoolExpBool_andArgumentsColumns" columns of table "call"
|
|
"""
|
|
enum CallSelectColumnCallAggregateBoolExpBool_andArgumentsColumns {
|
|
"""
|
|
column name
|
|
"""
|
|
success
|
|
}
|
|
|
|
"""
|
|
select "callAggregateBoolExpBool_orArgumentsColumns" columns of table "call"
|
|
"""
|
|
enum CallSelectColumnCallAggregateBoolExpBool_orArgumentsColumns {
|
|
"""
|
|
column name
|
|
"""
|
|
success
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "call"
|
|
"""
|
|
input CallStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: CallStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input CallStreamCursorValueInput {
|
|
address: [Int!]
|
|
args: jsonb
|
|
argsStr: [String!]
|
|
blockId: String
|
|
error: jsonb
|
|
extrinsicId: String
|
|
id: String
|
|
name: String
|
|
pallet: String
|
|
parentId: String
|
|
success: Boolean
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "cert"
|
|
"""
|
|
type Cert {
|
|
"""
|
|
An array relationship
|
|
"""
|
|
certHistory(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): [CertEvent!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
certHistoryAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): CertEventAggregate!
|
|
createdOn: Int!
|
|
expireOn: Int!
|
|
id: String!
|
|
isActive: Boolean!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
issuer: Identity
|
|
issuerId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
receiver: Identity
|
|
receiverId: String
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "cert"
|
|
"""
|
|
type CertAggregate {
|
|
aggregate: CertAggregateFields
|
|
nodes: [Cert!]!
|
|
}
|
|
|
|
input CertAggregateBoolExp {
|
|
bool_and: certAggregateBoolExpBool_and
|
|
bool_or: certAggregateBoolExpBool_or
|
|
count: certAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "cert"
|
|
"""
|
|
type CertAggregateFields {
|
|
avg: CertAvgFields
|
|
count(columns: [CertSelectColumn!], distinct: Boolean): Int!
|
|
max: CertMaxFields
|
|
min: CertMinFields
|
|
stddev: CertStddevFields
|
|
stddevPop: CertStddevPopFields
|
|
stddevSamp: CertStddevSampFields
|
|
sum: CertSumFields
|
|
varPop: CertVarPopFields
|
|
varSamp: CertVarSampFields
|
|
variance: CertVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "cert"
|
|
"""
|
|
input CertAggregateOrderBy {
|
|
avg: CertAvgOrderBy
|
|
count: OrderBy
|
|
max: CertMaxOrderBy
|
|
min: CertMinOrderBy
|
|
stddev: CertStddevOrderBy
|
|
stddevPop: CertStddevPopOrderBy
|
|
stddevSamp: CertStddevSampOrderBy
|
|
sum: CertSumOrderBy
|
|
varPop: CertVarPopOrderBy
|
|
varSamp: CertVarSampOrderBy
|
|
variance: CertVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type CertAvgFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "cert"
|
|
"""
|
|
input CertAvgOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "cert". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input CertBoolExp {
|
|
_and: [CertBoolExp!]
|
|
_not: CertBoolExp
|
|
_or: [CertBoolExp!]
|
|
certHistory: CertEventBoolExp
|
|
certHistoryAggregate: CertEventAggregateBoolExp
|
|
createdOn: IntComparisonExp
|
|
expireOn: IntComparisonExp
|
|
id: StringComparisonExp
|
|
isActive: BooleanComparisonExp
|
|
issuer: IdentityBoolExp
|
|
issuerId: StringComparisonExp
|
|
receiver: IdentityBoolExp
|
|
receiverId: StringComparisonExp
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "cert_event"
|
|
"""
|
|
type CertEvent {
|
|
blockNumber: Int!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
cert: Cert
|
|
certId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
event: Event
|
|
eventId: String
|
|
eventType: EventTypeEnum
|
|
id: String!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "cert_event"
|
|
"""
|
|
type CertEventAggregate {
|
|
aggregate: CertEventAggregateFields
|
|
nodes: [CertEvent!]!
|
|
}
|
|
|
|
input CertEventAggregateBoolExp {
|
|
count: certEventAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "cert_event"
|
|
"""
|
|
type CertEventAggregateFields {
|
|
avg: CertEventAvgFields
|
|
count(columns: [CertEventSelectColumn!], distinct: Boolean): Int!
|
|
max: CertEventMaxFields
|
|
min: CertEventMinFields
|
|
stddev: CertEventStddevFields
|
|
stddevPop: CertEventStddevPopFields
|
|
stddevSamp: CertEventStddevSampFields
|
|
sum: CertEventSumFields
|
|
varPop: CertEventVarPopFields
|
|
varSamp: CertEventVarSampFields
|
|
variance: CertEventVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "cert_event"
|
|
"""
|
|
input CertEventAggregateOrderBy {
|
|
avg: CertEventAvgOrderBy
|
|
count: OrderBy
|
|
max: CertEventMaxOrderBy
|
|
min: CertEventMinOrderBy
|
|
stddev: CertEventStddevOrderBy
|
|
stddevPop: CertEventStddevPopOrderBy
|
|
stddevSamp: CertEventStddevSampOrderBy
|
|
sum: CertEventSumOrderBy
|
|
varPop: CertEventVarPopOrderBy
|
|
varSamp: CertEventVarSampOrderBy
|
|
variance: CertEventVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type CertEventAvgFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "cert_event"
|
|
"""
|
|
input CertEventAvgOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "cert_event". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input CertEventBoolExp {
|
|
_and: [CertEventBoolExp!]
|
|
_not: CertEventBoolExp
|
|
_or: [CertEventBoolExp!]
|
|
blockNumber: IntComparisonExp
|
|
cert: CertBoolExp
|
|
certId: StringComparisonExp
|
|
event: EventBoolExp
|
|
eventId: StringComparisonExp
|
|
eventType: EventTypeEnumComparisonExp
|
|
id: StringComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type CertEventMaxFields {
|
|
blockNumber: Int
|
|
certId: String
|
|
eventId: String
|
|
id: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "cert_event"
|
|
"""
|
|
input CertEventMaxOrderBy {
|
|
blockNumber: OrderBy
|
|
certId: OrderBy
|
|
eventId: OrderBy
|
|
id: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type CertEventMinFields {
|
|
blockNumber: Int
|
|
certId: String
|
|
eventId: String
|
|
id: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "cert_event"
|
|
"""
|
|
input CertEventMinOrderBy {
|
|
blockNumber: OrderBy
|
|
certId: OrderBy
|
|
eventId: OrderBy
|
|
id: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "cert_event".
|
|
"""
|
|
input CertEventOrderBy {
|
|
blockNumber: OrderBy
|
|
cert: CertOrderBy
|
|
certId: OrderBy
|
|
event: EventOrderBy
|
|
eventId: OrderBy
|
|
eventType: OrderBy
|
|
id: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "cert_event"
|
|
"""
|
|
enum CertEventSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
blockNumber
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
certId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
eventId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
eventType
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type CertEventStddevFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "cert_event"
|
|
"""
|
|
input CertEventStddevOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type CertEventStddevPopFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "cert_event"
|
|
"""
|
|
input CertEventStddevPopOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type CertEventStddevSampFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "cert_event"
|
|
"""
|
|
input CertEventStddevSampOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "cert_event"
|
|
"""
|
|
input CertEventStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: CertEventStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input CertEventStreamCursorValueInput {
|
|
blockNumber: Int
|
|
certId: String
|
|
eventId: String
|
|
eventType: EventTypeEnum
|
|
id: String
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type CertEventSumFields {
|
|
blockNumber: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "cert_event"
|
|
"""
|
|
input CertEventSumOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type CertEventVarPopFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "cert_event"
|
|
"""
|
|
input CertEventVarPopOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type CertEventVarSampFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "cert_event"
|
|
"""
|
|
input CertEventVarSampOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type CertEventVarianceFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "cert_event"
|
|
"""
|
|
input CertEventVarianceOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type CertMaxFields {
|
|
createdOn: Int
|
|
expireOn: Int
|
|
id: String
|
|
issuerId: String
|
|
receiverId: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "cert"
|
|
"""
|
|
input CertMaxOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
id: OrderBy
|
|
issuerId: OrderBy
|
|
receiverId: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type CertMinFields {
|
|
createdOn: Int
|
|
expireOn: Int
|
|
id: String
|
|
issuerId: String
|
|
receiverId: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "cert"
|
|
"""
|
|
input CertMinOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
id: OrderBy
|
|
issuerId: OrderBy
|
|
receiverId: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "cert".
|
|
"""
|
|
input CertOrderBy {
|
|
certHistoryAggregate: CertEventAggregateOrderBy
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
id: OrderBy
|
|
isActive: OrderBy
|
|
issuer: IdentityOrderBy
|
|
issuerId: OrderBy
|
|
receiver: IdentityOrderBy
|
|
receiverId: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "cert"
|
|
"""
|
|
enum CertSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
createdOn
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
expireOn
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
isActive
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
issuerId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
receiverId
|
|
}
|
|
|
|
"""
|
|
select "certAggregateBoolExpBool_andArgumentsColumns" columns of table "cert"
|
|
"""
|
|
enum CertSelectColumnCertAggregateBoolExpBool_andArgumentsColumns {
|
|
"""
|
|
column name
|
|
"""
|
|
isActive
|
|
}
|
|
|
|
"""
|
|
select "certAggregateBoolExpBool_orArgumentsColumns" columns of table "cert"
|
|
"""
|
|
enum CertSelectColumnCertAggregateBoolExpBool_orArgumentsColumns {
|
|
"""
|
|
column name
|
|
"""
|
|
isActive
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type CertStddevFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "cert"
|
|
"""
|
|
input CertStddevOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type CertStddevPopFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "cert"
|
|
"""
|
|
input CertStddevPopOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type CertStddevSampFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "cert"
|
|
"""
|
|
input CertStddevSampOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "cert"
|
|
"""
|
|
input CertStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: CertStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input CertStreamCursorValueInput {
|
|
createdOn: Int
|
|
expireOn: Int
|
|
id: String
|
|
isActive: Boolean
|
|
issuerId: String
|
|
receiverId: String
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type CertSumFields {
|
|
createdOn: Int
|
|
expireOn: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "cert"
|
|
"""
|
|
input CertSumOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type CertVarPopFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "cert"
|
|
"""
|
|
input CertVarPopOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type CertVarSampFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "cert"
|
|
"""
|
|
input CertVarSampOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type CertVarianceFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "cert"
|
|
"""
|
|
input CertVarianceOrderBy {
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "change_owner_key"
|
|
"""
|
|
type ChangeOwnerKey {
|
|
blockNumber: Int!
|
|
id: String!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
identity: Identity
|
|
identityId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
next: Account
|
|
nextId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
previous: Account
|
|
previousId: String
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "change_owner_key"
|
|
"""
|
|
type ChangeOwnerKeyAggregate {
|
|
aggregate: ChangeOwnerKeyAggregateFields
|
|
nodes: [ChangeOwnerKey!]!
|
|
}
|
|
|
|
input ChangeOwnerKeyAggregateBoolExp {
|
|
count: changeOwnerKeyAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "change_owner_key"
|
|
"""
|
|
type ChangeOwnerKeyAggregateFields {
|
|
avg: ChangeOwnerKeyAvgFields
|
|
count(columns: [ChangeOwnerKeySelectColumn!], distinct: Boolean): Int!
|
|
max: ChangeOwnerKeyMaxFields
|
|
min: ChangeOwnerKeyMinFields
|
|
stddev: ChangeOwnerKeyStddevFields
|
|
stddevPop: ChangeOwnerKeyStddevPopFields
|
|
stddevSamp: ChangeOwnerKeyStddevSampFields
|
|
sum: ChangeOwnerKeySumFields
|
|
varPop: ChangeOwnerKeyVarPopFields
|
|
varSamp: ChangeOwnerKeyVarSampFields
|
|
variance: ChangeOwnerKeyVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyAggregateOrderBy {
|
|
avg: ChangeOwnerKeyAvgOrderBy
|
|
count: OrderBy
|
|
max: ChangeOwnerKeyMaxOrderBy
|
|
min: ChangeOwnerKeyMinOrderBy
|
|
stddev: ChangeOwnerKeyStddevOrderBy
|
|
stddevPop: ChangeOwnerKeyStddevPopOrderBy
|
|
stddevSamp: ChangeOwnerKeyStddevSampOrderBy
|
|
sum: ChangeOwnerKeySumOrderBy
|
|
varPop: ChangeOwnerKeyVarPopOrderBy
|
|
varSamp: ChangeOwnerKeyVarSampOrderBy
|
|
variance: ChangeOwnerKeyVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type ChangeOwnerKeyAvgFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyAvgOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "change_owner_key". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input ChangeOwnerKeyBoolExp {
|
|
_and: [ChangeOwnerKeyBoolExp!]
|
|
_not: ChangeOwnerKeyBoolExp
|
|
_or: [ChangeOwnerKeyBoolExp!]
|
|
blockNumber: IntComparisonExp
|
|
id: StringComparisonExp
|
|
identity: IdentityBoolExp
|
|
identityId: StringComparisonExp
|
|
next: AccountBoolExp
|
|
nextId: StringComparisonExp
|
|
previous: AccountBoolExp
|
|
previousId: StringComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type ChangeOwnerKeyMaxFields {
|
|
blockNumber: Int
|
|
id: String
|
|
identityId: String
|
|
nextId: String
|
|
previousId: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyMaxOrderBy {
|
|
blockNumber: OrderBy
|
|
id: OrderBy
|
|
identityId: OrderBy
|
|
nextId: OrderBy
|
|
previousId: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type ChangeOwnerKeyMinFields {
|
|
blockNumber: Int
|
|
id: String
|
|
identityId: String
|
|
nextId: String
|
|
previousId: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyMinOrderBy {
|
|
blockNumber: OrderBy
|
|
id: OrderBy
|
|
identityId: OrderBy
|
|
nextId: OrderBy
|
|
previousId: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "change_owner_key".
|
|
"""
|
|
input ChangeOwnerKeyOrderBy {
|
|
blockNumber: OrderBy
|
|
id: OrderBy
|
|
identity: IdentityOrderBy
|
|
identityId: OrderBy
|
|
next: AccountOrderBy
|
|
nextId: OrderBy
|
|
previous: AccountOrderBy
|
|
previousId: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "change_owner_key"
|
|
"""
|
|
enum ChangeOwnerKeySelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
blockNumber
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
identityId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
nextId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
previousId
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type ChangeOwnerKeyStddevFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyStddevOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type ChangeOwnerKeyStddevPopFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyStddevPopOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type ChangeOwnerKeyStddevSampFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyStddevSampOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: ChangeOwnerKeyStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input ChangeOwnerKeyStreamCursorValueInput {
|
|
blockNumber: Int
|
|
id: String
|
|
identityId: String
|
|
nextId: String
|
|
previousId: String
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type ChangeOwnerKeySumFields {
|
|
blockNumber: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeySumOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type ChangeOwnerKeyVarPopFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyVarPopOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type ChangeOwnerKeyVarSampFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyVarSampOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type ChangeOwnerKeyVarianceFields {
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "change_owner_key"
|
|
"""
|
|
input ChangeOwnerKeyVarianceOrderBy {
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
enum CounterLevelEnum {
|
|
GLOBAL
|
|
ITEM
|
|
PALLET
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "CounterLevelEnum". All fields are combined with logical 'AND'.
|
|
"""
|
|
input CounterLevelEnumComparisonExp {
|
|
_eq: CounterLevelEnum
|
|
_in: [CounterLevelEnum!]
|
|
_isNull: Boolean
|
|
_neq: CounterLevelEnum
|
|
_nin: [CounterLevelEnum!]
|
|
}
|
|
|
|
"""
|
|
ordering argument of a cursor
|
|
"""
|
|
enum CursorOrdering {
|
|
"""
|
|
ascending ordering of the cursor
|
|
"""
|
|
ASC
|
|
|
|
"""
|
|
descending ordering of the cursor
|
|
"""
|
|
DESC
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "event"
|
|
"""
|
|
type Event {
|
|
args(
|
|
"""
|
|
JSON select path
|
|
"""
|
|
path: String
|
|
): jsonb
|
|
argsStr: [String!]
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
block: Block
|
|
blockId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
call: Call
|
|
callId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
extrinsic: Extrinsic
|
|
extrinsicId: String
|
|
id: String!
|
|
index: Int!
|
|
name: String!
|
|
pallet: String!
|
|
phase: String!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "event"
|
|
"""
|
|
type EventAggregate {
|
|
aggregate: EventAggregateFields
|
|
nodes: [Event!]!
|
|
}
|
|
|
|
input EventAggregateBoolExp {
|
|
count: eventAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "event"
|
|
"""
|
|
type EventAggregateFields {
|
|
avg: EventAvgFields
|
|
count(columns: [EventSelectColumn!], distinct: Boolean): Int!
|
|
max: EventMaxFields
|
|
min: EventMinFields
|
|
stddev: EventStddevFields
|
|
stddevPop: EventStddevPopFields
|
|
stddevSamp: EventStddevSampFields
|
|
sum: EventSumFields
|
|
varPop: EventVarPopFields
|
|
varSamp: EventVarSampFields
|
|
variance: EventVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "event"
|
|
"""
|
|
input EventAggregateOrderBy {
|
|
avg: EventAvgOrderBy
|
|
count: OrderBy
|
|
max: EventMaxOrderBy
|
|
min: EventMinOrderBy
|
|
stddev: EventStddevOrderBy
|
|
stddevPop: EventStddevPopOrderBy
|
|
stddevSamp: EventStddevSampOrderBy
|
|
sum: EventSumOrderBy
|
|
varPop: EventVarPopOrderBy
|
|
varSamp: EventVarSampOrderBy
|
|
variance: EventVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type EventAvgFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "event"
|
|
"""
|
|
input EventAvgOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "event". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input EventBoolExp {
|
|
_and: [EventBoolExp!]
|
|
_not: EventBoolExp
|
|
_or: [EventBoolExp!]
|
|
args: JsonbComparisonExp
|
|
argsStr: StringArrayComparisonExp
|
|
block: BlockBoolExp
|
|
blockId: StringComparisonExp
|
|
call: CallBoolExp
|
|
callId: StringComparisonExp
|
|
extrinsic: ExtrinsicBoolExp
|
|
extrinsicId: StringComparisonExp
|
|
id: StringComparisonExp
|
|
index: IntComparisonExp
|
|
name: StringComparisonExp
|
|
pallet: StringComparisonExp
|
|
phase: StringComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type EventMaxFields {
|
|
argsStr: [String!]
|
|
blockId: String
|
|
callId: String
|
|
extrinsicId: String
|
|
id: String
|
|
index: Int
|
|
name: String
|
|
pallet: String
|
|
phase: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "event"
|
|
"""
|
|
input EventMaxOrderBy {
|
|
argsStr: OrderBy
|
|
blockId: OrderBy
|
|
callId: OrderBy
|
|
extrinsicId: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
name: OrderBy
|
|
pallet: OrderBy
|
|
phase: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type EventMinFields {
|
|
argsStr: [String!]
|
|
blockId: String
|
|
callId: String
|
|
extrinsicId: String
|
|
id: String
|
|
index: Int
|
|
name: String
|
|
pallet: String
|
|
phase: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "event"
|
|
"""
|
|
input EventMinOrderBy {
|
|
argsStr: OrderBy
|
|
blockId: OrderBy
|
|
callId: OrderBy
|
|
extrinsicId: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
name: OrderBy
|
|
pallet: OrderBy
|
|
phase: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "event".
|
|
"""
|
|
input EventOrderBy {
|
|
args: OrderBy
|
|
argsStr: OrderBy
|
|
block: BlockOrderBy
|
|
blockId: OrderBy
|
|
call: CallOrderBy
|
|
callId: OrderBy
|
|
extrinsic: ExtrinsicOrderBy
|
|
extrinsicId: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
name: OrderBy
|
|
pallet: OrderBy
|
|
phase: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "event"
|
|
"""
|
|
enum EventSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
args
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
argsStr
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
blockId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
callId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
extrinsicId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
index
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
name
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
pallet
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
phase
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type EventStddevFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "event"
|
|
"""
|
|
input EventStddevOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type EventStddevPopFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "event"
|
|
"""
|
|
input EventStddevPopOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type EventStddevSampFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "event"
|
|
"""
|
|
input EventStddevSampOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "event"
|
|
"""
|
|
input EventStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: EventStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input EventStreamCursorValueInput {
|
|
args: jsonb
|
|
argsStr: [String!]
|
|
blockId: String
|
|
callId: String
|
|
extrinsicId: String
|
|
id: String
|
|
index: Int
|
|
name: String
|
|
pallet: String
|
|
phase: String
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type EventSumFields {
|
|
index: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "event"
|
|
"""
|
|
input EventSumOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
enum EventTypeEnum {
|
|
CREATION
|
|
REMOVAL
|
|
RENEWAL
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "EventTypeEnum". All fields are combined with logical 'AND'.
|
|
"""
|
|
input EventTypeEnumComparisonExp {
|
|
_eq: EventTypeEnum
|
|
_in: [EventTypeEnum!]
|
|
_isNull: Boolean
|
|
_neq: EventTypeEnum
|
|
_nin: [EventTypeEnum!]
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type EventVarPopFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "event"
|
|
"""
|
|
input EventVarPopOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type EventVarSampFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "event"
|
|
"""
|
|
input EventVarSampOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type EventVarianceFields {
|
|
index: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "event"
|
|
"""
|
|
input EventVarianceOrderBy {
|
|
index: OrderBy
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "extrinsic"
|
|
"""
|
|
type Extrinsic {
|
|
"""
|
|
An object relationship
|
|
"""
|
|
block: Block
|
|
blockId: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
call: Call
|
|
callId: String
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
calls(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): [Call!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
callsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): CallAggregate!
|
|
error(
|
|
"""
|
|
JSON select path
|
|
"""
|
|
path: String
|
|
): jsonb
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
events(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): [Event!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
eventsAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): EventAggregate!
|
|
fee: numeric
|
|
hash: bytea!
|
|
id: String!
|
|
index: Int!
|
|
signature(
|
|
"""
|
|
JSON select path
|
|
"""
|
|
path: String
|
|
): jsonb
|
|
success: Boolean
|
|
tip: numeric
|
|
version: Int!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "extrinsic"
|
|
"""
|
|
type ExtrinsicAggregate {
|
|
aggregate: ExtrinsicAggregateFields
|
|
nodes: [Extrinsic!]!
|
|
}
|
|
|
|
input ExtrinsicAggregateBoolExp {
|
|
bool_and: extrinsicAggregateBoolExpBool_and
|
|
bool_or: extrinsicAggregateBoolExpBool_or
|
|
count: extrinsicAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "extrinsic"
|
|
"""
|
|
type ExtrinsicAggregateFields {
|
|
avg: ExtrinsicAvgFields
|
|
count(columns: [ExtrinsicSelectColumn!], distinct: Boolean): Int!
|
|
max: ExtrinsicMaxFields
|
|
min: ExtrinsicMinFields
|
|
stddev: ExtrinsicStddevFields
|
|
stddevPop: ExtrinsicStddevPopFields
|
|
stddevSamp: ExtrinsicStddevSampFields
|
|
sum: ExtrinsicSumFields
|
|
varPop: ExtrinsicVarPopFields
|
|
varSamp: ExtrinsicVarSampFields
|
|
variance: ExtrinsicVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "extrinsic"
|
|
"""
|
|
input ExtrinsicAggregateOrderBy {
|
|
avg: ExtrinsicAvgOrderBy
|
|
count: OrderBy
|
|
max: ExtrinsicMaxOrderBy
|
|
min: ExtrinsicMinOrderBy
|
|
stddev: ExtrinsicStddevOrderBy
|
|
stddevPop: ExtrinsicStddevPopOrderBy
|
|
stddevSamp: ExtrinsicStddevSampOrderBy
|
|
sum: ExtrinsicSumOrderBy
|
|
varPop: ExtrinsicVarPopOrderBy
|
|
varSamp: ExtrinsicVarSampOrderBy
|
|
variance: ExtrinsicVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type ExtrinsicAvgFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicAvgOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "extrinsic". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input ExtrinsicBoolExp {
|
|
_and: [ExtrinsicBoolExp!]
|
|
_not: ExtrinsicBoolExp
|
|
_or: [ExtrinsicBoolExp!]
|
|
block: BlockBoolExp
|
|
blockId: StringComparisonExp
|
|
call: CallBoolExp
|
|
callId: StringComparisonExp
|
|
calls: CallBoolExp
|
|
callsAggregate: CallAggregateBoolExp
|
|
error: JsonbComparisonExp
|
|
events: EventBoolExp
|
|
eventsAggregate: EventAggregateBoolExp
|
|
fee: NumericComparisonExp
|
|
hash: ByteaComparisonExp
|
|
id: StringComparisonExp
|
|
index: IntComparisonExp
|
|
signature: JsonbComparisonExp
|
|
success: BooleanComparisonExp
|
|
tip: NumericComparisonExp
|
|
version: IntComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type ExtrinsicMaxFields {
|
|
blockId: String
|
|
callId: String
|
|
fee: numeric
|
|
id: String
|
|
index: Int
|
|
tip: numeric
|
|
version: Int
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicMaxOrderBy {
|
|
blockId: OrderBy
|
|
callId: OrderBy
|
|
fee: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type ExtrinsicMinFields {
|
|
blockId: String
|
|
callId: String
|
|
fee: numeric
|
|
id: String
|
|
index: Int
|
|
tip: numeric
|
|
version: Int
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicMinOrderBy {
|
|
blockId: OrderBy
|
|
callId: OrderBy
|
|
fee: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "extrinsic".
|
|
"""
|
|
input ExtrinsicOrderBy {
|
|
block: BlockOrderBy
|
|
blockId: OrderBy
|
|
call: CallOrderBy
|
|
callId: OrderBy
|
|
callsAggregate: CallAggregateOrderBy
|
|
error: OrderBy
|
|
eventsAggregate: EventAggregateOrderBy
|
|
fee: OrderBy
|
|
hash: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
signature: OrderBy
|
|
success: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "extrinsic"
|
|
"""
|
|
enum ExtrinsicSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
blockId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
callId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
error
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
fee
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
hash
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
index
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
signature
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
success
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
tip
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
version
|
|
}
|
|
|
|
"""
|
|
select "extrinsicAggregateBoolExpBool_andArgumentsColumns" columns of table "extrinsic"
|
|
"""
|
|
enum ExtrinsicSelectColumnExtrinsicAggregateBoolExpBool_andArgumentsColumns {
|
|
"""
|
|
column name
|
|
"""
|
|
success
|
|
}
|
|
|
|
"""
|
|
select "extrinsicAggregateBoolExpBool_orArgumentsColumns" columns of table "extrinsic"
|
|
"""
|
|
enum ExtrinsicSelectColumnExtrinsicAggregateBoolExpBool_orArgumentsColumns {
|
|
"""
|
|
column name
|
|
"""
|
|
success
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type ExtrinsicStddevFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicStddevOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type ExtrinsicStddevPopFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicStddevPopOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type ExtrinsicStddevSampFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicStddevSampOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "extrinsic"
|
|
"""
|
|
input ExtrinsicStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: ExtrinsicStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input ExtrinsicStreamCursorValueInput {
|
|
blockId: String
|
|
callId: String
|
|
error: jsonb
|
|
fee: numeric
|
|
hash: bytea
|
|
id: String
|
|
index: Int
|
|
signature: jsonb
|
|
success: Boolean
|
|
tip: numeric
|
|
version: Int
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type ExtrinsicSumFields {
|
|
fee: numeric
|
|
index: Int
|
|
tip: numeric
|
|
version: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicSumOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type ExtrinsicVarPopFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicVarPopOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type ExtrinsicVarSampFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicVarSampOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type ExtrinsicVarianceFields {
|
|
fee: Float
|
|
index: Float
|
|
tip: Float
|
|
version: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "extrinsic"
|
|
"""
|
|
input ExtrinsicVarianceOrderBy {
|
|
fee: OrderBy
|
|
index: OrderBy
|
|
tip: OrderBy
|
|
version: OrderBy
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "identity"
|
|
"""
|
|
type Identity {
|
|
"""
|
|
An object relationship
|
|
"""
|
|
account: Account
|
|
accountId: String
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
certIssued(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): [Cert!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
certIssuedAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): CertAggregate!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
certReceived(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): [Cert!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
certReceivedAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): CertAggregate!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
createdIn: Event
|
|
createdInId: String
|
|
createdOn: Int!
|
|
expireOn: Int!
|
|
id: String!
|
|
index: Int!
|
|
isMember: Boolean!
|
|
lastChangeOn: Int!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
linkedAccount(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [AccountSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [AccountOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): [Account!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
linkedAccountAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [AccountSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [AccountOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): AccountAggregate!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
membershipHistory(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [MembershipEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [MembershipEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): [MembershipEvent!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
membershipHistoryAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [MembershipEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [MembershipEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): MembershipEventAggregate!
|
|
name: String!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
ownerKeyChange(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): [ChangeOwnerKey!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
ownerKeyChangeAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): ChangeOwnerKeyAggregate!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
smithCertIssued(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): [SmithCert!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
smithCertIssuedAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): SmithCertAggregate!
|
|
|
|
"""
|
|
An array relationship
|
|
"""
|
|
smithCertReceived(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): [SmithCert!]!
|
|
|
|
"""
|
|
An aggregate relationship
|
|
"""
|
|
smithCertReceivedAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): SmithCertAggregate!
|
|
smithStatus: SmithStatusEnum
|
|
status: IdentityStatusEnum
|
|
|
|
"""
|
|
"Get UD History by Identity"
|
|
"""
|
|
udHistory(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): [UdHistory!]
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "identity"
|
|
"""
|
|
type IdentityAggregate {
|
|
aggregate: IdentityAggregateFields
|
|
nodes: [Identity!]!
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "identity"
|
|
"""
|
|
type IdentityAggregateFields {
|
|
avg: IdentityAvgFields
|
|
count(columns: [IdentitySelectColumn!], distinct: Boolean): Int!
|
|
max: IdentityMaxFields
|
|
min: IdentityMinFields
|
|
stddev: IdentityStddevFields
|
|
stddevPop: IdentityStddevPopFields
|
|
stddevSamp: IdentityStddevSampFields
|
|
sum: IdentitySumFields
|
|
varPop: IdentityVarPopFields
|
|
varSamp: IdentityVarSampFields
|
|
variance: IdentityVarianceFields
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type IdentityAvgFields {
|
|
createdOn: Float
|
|
expireOn: Float
|
|
index: Float
|
|
lastChangeOn: Float
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "identity". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input IdentityBoolExp {
|
|
_and: [IdentityBoolExp!]
|
|
_not: IdentityBoolExp
|
|
_or: [IdentityBoolExp!]
|
|
account: AccountBoolExp
|
|
accountId: StringComparisonExp
|
|
certIssued: CertBoolExp
|
|
certIssuedAggregate: CertAggregateBoolExp
|
|
certReceived: CertBoolExp
|
|
certReceivedAggregate: CertAggregateBoolExp
|
|
createdIn: EventBoolExp
|
|
createdInId: StringComparisonExp
|
|
createdOn: IntComparisonExp
|
|
expireOn: IntComparisonExp
|
|
id: StringComparisonExp
|
|
index: IntComparisonExp
|
|
isMember: BooleanComparisonExp
|
|
lastChangeOn: IntComparisonExp
|
|
linkedAccount: AccountBoolExp
|
|
linkedAccountAggregate: AccountAggregateBoolExp
|
|
membershipHistory: MembershipEventBoolExp
|
|
membershipHistoryAggregate: MembershipEventAggregateBoolExp
|
|
name: StringComparisonExp
|
|
ownerKeyChange: ChangeOwnerKeyBoolExp
|
|
ownerKeyChangeAggregate: ChangeOwnerKeyAggregateBoolExp
|
|
smithCertIssued: SmithCertBoolExp
|
|
smithCertIssuedAggregate: SmithCertAggregateBoolExp
|
|
smithCertReceived: SmithCertBoolExp
|
|
smithCertReceivedAggregate: SmithCertAggregateBoolExp
|
|
smithStatus: SmithStatusEnumComparisonExp
|
|
status: IdentityStatusEnumComparisonExp
|
|
udHistory: UdHistoryBoolExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type IdentityMaxFields {
|
|
accountId: String
|
|
createdInId: String
|
|
createdOn: Int
|
|
expireOn: Int
|
|
id: String
|
|
index: Int
|
|
lastChangeOn: Int
|
|
name: String
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type IdentityMinFields {
|
|
accountId: String
|
|
createdInId: String
|
|
createdOn: Int
|
|
expireOn: Int
|
|
id: String
|
|
index: Int
|
|
lastChangeOn: Int
|
|
name: String
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "identity".
|
|
"""
|
|
input IdentityOrderBy {
|
|
account: AccountOrderBy
|
|
accountId: OrderBy
|
|
certIssuedAggregate: CertAggregateOrderBy
|
|
certReceivedAggregate: CertAggregateOrderBy
|
|
createdIn: EventOrderBy
|
|
createdInId: OrderBy
|
|
createdOn: OrderBy
|
|
expireOn: OrderBy
|
|
id: OrderBy
|
|
index: OrderBy
|
|
isMember: OrderBy
|
|
lastChangeOn: OrderBy
|
|
linkedAccountAggregate: AccountAggregateOrderBy
|
|
membershipHistoryAggregate: MembershipEventAggregateOrderBy
|
|
name: OrderBy
|
|
ownerKeyChangeAggregate: ChangeOwnerKeyAggregateOrderBy
|
|
smithCertIssuedAggregate: SmithCertAggregateOrderBy
|
|
smithCertReceivedAggregate: SmithCertAggregateOrderBy
|
|
smithStatus: OrderBy
|
|
status: OrderBy
|
|
udHistoryAggregate: UdHistoryAggregateOrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "identity"
|
|
"""
|
|
enum IdentitySelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
accountId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
createdInId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
createdOn
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
expireOn
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
index
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
isMember
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
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
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input SmithCertStreamCursorValueInput {
|
|
createdOn: Int
|
|
id: String
|
|
issuerId: String
|
|
receiverId: String
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type SmithCertSumFields {
|
|
createdOn: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "smith_cert"
|
|
"""
|
|
input SmithCertSumOrderBy {
|
|
createdOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type SmithCertVarPopFields {
|
|
createdOn: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "smith_cert"
|
|
"""
|
|
input SmithCertVarPopOrderBy {
|
|
createdOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type SmithCertVarSampFields {
|
|
createdOn: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "smith_cert"
|
|
"""
|
|
input SmithCertVarSampOrderBy {
|
|
createdOn: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type SmithCertVarianceFields {
|
|
createdOn: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "smith_cert"
|
|
"""
|
|
input SmithCertVarianceOrderBy {
|
|
createdOn: OrderBy
|
|
}
|
|
|
|
enum SmithStatusEnum {
|
|
EXCLUDED
|
|
INVITED
|
|
PENDING
|
|
SMITH
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "SmithStatusEnum". All fields are combined with logical 'AND'.
|
|
"""
|
|
input SmithStatusEnumComparisonExp {
|
|
_eq: SmithStatusEnum
|
|
_in: [SmithStatusEnum!]
|
|
_isNull: Boolean
|
|
_neq: SmithStatusEnum
|
|
_nin: [SmithStatusEnum!]
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.
|
|
"""
|
|
input StringArrayComparisonExp {
|
|
"""
|
|
is the array contained in the given array value
|
|
"""
|
|
_containedIn: [String!]
|
|
|
|
"""
|
|
does the array contain the given value
|
|
"""
|
|
_contains: [String!]
|
|
_eq: [String!]
|
|
_gt: [String!]
|
|
_gte: [String!]
|
|
_in: [[String!]!]
|
|
_isNull: Boolean
|
|
_lt: [String!]
|
|
_lte: [String!]
|
|
_neq: [String!]
|
|
_nin: [[String!]!]
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.
|
|
"""
|
|
input StringComparisonExp {
|
|
_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
|
|
_isNull: 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
|
|
}
|
|
|
|
"""
|
|
Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'.
|
|
"""
|
|
input TimestamptzComparisonExp {
|
|
_eq: timestamptz
|
|
_gt: timestamptz
|
|
_gte: timestamptz
|
|
_in: [timestamptz!]
|
|
_isNull: Boolean
|
|
_lt: timestamptz
|
|
_lte: timestamptz
|
|
_neq: timestamptz
|
|
_nin: [timestamptz!]
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "transfer"
|
|
"""
|
|
type Transfer {
|
|
amount: numeric!
|
|
blockNumber: Int!
|
|
comment: String
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
from: Account
|
|
fromId: String
|
|
id: String!
|
|
timestamp: timestamptz!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
to: Account
|
|
toId: String
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "transfer"
|
|
"""
|
|
type TransferAggregate {
|
|
aggregate: TransferAggregateFields
|
|
nodes: [Transfer!]!
|
|
}
|
|
|
|
input TransferAggregateBoolExp {
|
|
count: transferAggregateBoolExpCount
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "transfer"
|
|
"""
|
|
type TransferAggregateFields {
|
|
avg: TransferAvgFields
|
|
count(columns: [TransferSelectColumn!], distinct: Boolean): Int!
|
|
max: TransferMaxFields
|
|
min: TransferMinFields
|
|
stddev: TransferStddevFields
|
|
stddevPop: TransferStddevPopFields
|
|
stddevSamp: TransferStddevSampFields
|
|
sum: TransferSumFields
|
|
varPop: TransferVarPopFields
|
|
varSamp: TransferVarSampFields
|
|
variance: TransferVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "transfer"
|
|
"""
|
|
input TransferAggregateOrderBy {
|
|
avg: TransferAvgOrderBy
|
|
count: OrderBy
|
|
max: TransferMaxOrderBy
|
|
min: TransferMinOrderBy
|
|
stddev: TransferStddevOrderBy
|
|
stddevPop: TransferStddevPopOrderBy
|
|
stddevSamp: TransferStddevSampOrderBy
|
|
sum: TransferSumOrderBy
|
|
varPop: TransferVarPopOrderBy
|
|
varSamp: TransferVarSampOrderBy
|
|
variance: TransferVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type TransferAvgFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "transfer"
|
|
"""
|
|
input TransferAvgOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "transfer". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input TransferBoolExp {
|
|
_and: [TransferBoolExp!]
|
|
_not: TransferBoolExp
|
|
_or: [TransferBoolExp!]
|
|
amount: NumericComparisonExp
|
|
blockNumber: IntComparisonExp
|
|
comment: StringComparisonExp
|
|
from: AccountBoolExp
|
|
fromId: StringComparisonExp
|
|
id: StringComparisonExp
|
|
timestamp: TimestamptzComparisonExp
|
|
to: AccountBoolExp
|
|
toId: StringComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type TransferMaxFields {
|
|
amount: numeric
|
|
blockNumber: Int
|
|
comment: String
|
|
fromId: String
|
|
id: String
|
|
timestamp: timestamptz
|
|
toId: String
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "transfer"
|
|
"""
|
|
input TransferMaxOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
comment: OrderBy
|
|
fromId: OrderBy
|
|
id: OrderBy
|
|
timestamp: OrderBy
|
|
toId: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type TransferMinFields {
|
|
amount: numeric
|
|
blockNumber: Int
|
|
comment: String
|
|
fromId: String
|
|
id: String
|
|
timestamp: timestamptz
|
|
toId: String
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "transfer"
|
|
"""
|
|
input TransferMinOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
comment: OrderBy
|
|
fromId: OrderBy
|
|
id: OrderBy
|
|
timestamp: OrderBy
|
|
toId: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "transfer".
|
|
"""
|
|
input TransferOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
comment: OrderBy
|
|
from: AccountOrderBy
|
|
fromId: OrderBy
|
|
id: OrderBy
|
|
timestamp: OrderBy
|
|
to: AccountOrderBy
|
|
toId: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "transfer"
|
|
"""
|
|
enum TransferSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
amount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
blockNumber
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
comment
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
fromId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
timestamp
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
toId
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type TransferStddevFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "transfer"
|
|
"""
|
|
input TransferStddevOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type TransferStddevPopFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "transfer"
|
|
"""
|
|
input TransferStddevPopOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type TransferStddevSampFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "transfer"
|
|
"""
|
|
input TransferStddevSampOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "transfer"
|
|
"""
|
|
input TransferStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: TransferStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input TransferStreamCursorValueInput {
|
|
amount: numeric
|
|
blockNumber: Int
|
|
comment: String
|
|
fromId: String
|
|
id: String
|
|
timestamp: timestamptz
|
|
toId: String
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type TransferSumFields {
|
|
amount: numeric
|
|
blockNumber: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "transfer"
|
|
"""
|
|
input TransferSumOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type TransferVarPopFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "transfer"
|
|
"""
|
|
input TransferVarPopOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type TransferVarSampFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "transfer"
|
|
"""
|
|
input TransferVarSampOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type TransferVarianceFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "transfer"
|
|
"""
|
|
input TransferVarianceOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "ud_history"
|
|
"""
|
|
type UdHistory {
|
|
amount: Int!
|
|
blockNumber: Int!
|
|
id: String!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
identity: Identity
|
|
identityId: String
|
|
timestamp: timestamptz!
|
|
}
|
|
|
|
type UdHistoryAggregate {
|
|
aggregate: UdHistoryAggregateFields
|
|
nodes: [UdHistory!]!
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "ud_history"
|
|
"""
|
|
type UdHistoryAggregateFields {
|
|
avg: UdHistoryAvgFields
|
|
count(columns: [UdHistorySelectColumn!], distinct: Boolean): Int!
|
|
max: UdHistoryMaxFields
|
|
min: UdHistoryMinFields
|
|
stddev: UdHistoryStddevFields
|
|
stddevPop: UdHistoryStddevPopFields
|
|
stddevSamp: UdHistoryStddevSampFields
|
|
sum: UdHistorySumFields
|
|
varPop: UdHistoryVarPopFields
|
|
varSamp: UdHistoryVarSampFields
|
|
variance: UdHistoryVarianceFields
|
|
}
|
|
|
|
"""
|
|
order by aggregate values of table "ud_history"
|
|
"""
|
|
input UdHistoryAggregateOrderBy {
|
|
avg: UdHistoryAvgOrderBy
|
|
count: OrderBy
|
|
max: UdHistoryMaxOrderBy
|
|
min: UdHistoryMinOrderBy
|
|
stddev: UdHistoryStddevOrderBy
|
|
stddevPop: UdHistoryStddevPopOrderBy
|
|
stddevSamp: UdHistoryStddevSampOrderBy
|
|
sum: UdHistorySumOrderBy
|
|
varPop: UdHistoryVarPopOrderBy
|
|
varSamp: UdHistoryVarSampOrderBy
|
|
variance: UdHistoryVarianceOrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type UdHistoryAvgFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by avg() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryAvgOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "ud_history". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input UdHistoryBoolExp {
|
|
_and: [UdHistoryBoolExp!]
|
|
_not: UdHistoryBoolExp
|
|
_or: [UdHistoryBoolExp!]
|
|
amount: IntComparisonExp
|
|
blockNumber: IntComparisonExp
|
|
id: StringComparisonExp
|
|
identity: IdentityBoolExp
|
|
identityId: StringComparisonExp
|
|
timestamp: TimestamptzComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type UdHistoryMaxFields {
|
|
amount: Int
|
|
blockNumber: Int
|
|
id: String
|
|
identityId: String
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
order by max() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryMaxOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
id: OrderBy
|
|
identityId: OrderBy
|
|
timestamp: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type UdHistoryMinFields {
|
|
amount: Int
|
|
blockNumber: Int
|
|
id: String
|
|
identityId: String
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
order by min() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryMinOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
id: OrderBy
|
|
identityId: OrderBy
|
|
timestamp: OrderBy
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "ud_history".
|
|
"""
|
|
input UdHistoryOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
id: OrderBy
|
|
identity: IdentityOrderBy
|
|
identityId: OrderBy
|
|
timestamp: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "ud_history"
|
|
"""
|
|
enum UdHistorySelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
amount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
blockNumber
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
identityId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
timestamp
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type UdHistoryStddevFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddev() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryStddevOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type UdHistoryStddevPopFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevPop() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryStddevPopOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type UdHistoryStddevSampFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by stddevSamp() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryStddevSampOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "ud_history"
|
|
"""
|
|
input UdHistoryStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: UdHistoryStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input UdHistoryStreamCursorValueInput {
|
|
amount: Int
|
|
blockNumber: Int
|
|
id: String
|
|
identityId: String
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type UdHistorySumFields {
|
|
amount: Int
|
|
blockNumber: Int
|
|
}
|
|
|
|
"""
|
|
order by sum() on columns of table "ud_history"
|
|
"""
|
|
input UdHistorySumOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type UdHistoryVarPopFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varPop() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryVarPopOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type UdHistoryVarSampFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by varSamp() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryVarSampOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type UdHistoryVarianceFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
}
|
|
|
|
"""
|
|
order by variance() on columns of table "ud_history"
|
|
"""
|
|
input UdHistoryVarianceOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "ud_reeval"
|
|
"""
|
|
type UdReeval {
|
|
blockNumber: Int!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
event: Event
|
|
eventId: String
|
|
id: String!
|
|
membersCount: Int!
|
|
monetaryMass: numeric!
|
|
newUdAmount: Int!
|
|
timestamp: timestamptz!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "ud_reeval"
|
|
"""
|
|
type UdReevalAggregate {
|
|
aggregate: UdReevalAggregateFields
|
|
nodes: [UdReeval!]!
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "ud_reeval"
|
|
"""
|
|
type UdReevalAggregateFields {
|
|
avg: UdReevalAvgFields
|
|
count(columns: [UdReevalSelectColumn!], distinct: Boolean): Int!
|
|
max: UdReevalMaxFields
|
|
min: UdReevalMinFields
|
|
stddev: UdReevalStddevFields
|
|
stddevPop: UdReevalStddevPopFields
|
|
stddevSamp: UdReevalStddevSampFields
|
|
sum: UdReevalSumFields
|
|
varPop: UdReevalVarPopFields
|
|
varSamp: UdReevalVarSampFields
|
|
variance: UdReevalVarianceFields
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type UdReevalAvgFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "ud_reeval". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input UdReevalBoolExp {
|
|
_and: [UdReevalBoolExp!]
|
|
_not: UdReevalBoolExp
|
|
_or: [UdReevalBoolExp!]
|
|
blockNumber: IntComparisonExp
|
|
event: EventBoolExp
|
|
eventId: StringComparisonExp
|
|
id: StringComparisonExp
|
|
membersCount: IntComparisonExp
|
|
monetaryMass: NumericComparisonExp
|
|
newUdAmount: IntComparisonExp
|
|
timestamp: TimestamptzComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type UdReevalMaxFields {
|
|
blockNumber: Int
|
|
eventId: String
|
|
id: String
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
newUdAmount: Int
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type UdReevalMinFields {
|
|
blockNumber: Int
|
|
eventId: String
|
|
id: String
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
newUdAmount: Int
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "ud_reeval".
|
|
"""
|
|
input UdReevalOrderBy {
|
|
blockNumber: OrderBy
|
|
event: EventOrderBy
|
|
eventId: OrderBy
|
|
id: OrderBy
|
|
membersCount: OrderBy
|
|
monetaryMass: OrderBy
|
|
newUdAmount: OrderBy
|
|
timestamp: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "ud_reeval"
|
|
"""
|
|
enum UdReevalSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
blockNumber
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
eventId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
membersCount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
monetaryMass
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
newUdAmount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
timestamp
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type UdReevalStddevFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type UdReevalStddevPopFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type UdReevalStddevSampFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "ud_reeval"
|
|
"""
|
|
input UdReevalStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: UdReevalStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input UdReevalStreamCursorValueInput {
|
|
blockNumber: Int
|
|
eventId: String
|
|
id: String
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
newUdAmount: Int
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type UdReevalSumFields {
|
|
blockNumber: Int
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
newUdAmount: Int
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type UdReevalVarPopFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type UdReevalVarSampFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type UdReevalVarianceFields {
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
newUdAmount: Float
|
|
}
|
|
|
|
"""
|
|
columns and relationships of "universal_dividend"
|
|
"""
|
|
type UniversalDividend {
|
|
amount: Int!
|
|
blockNumber: Int!
|
|
|
|
"""
|
|
An object relationship
|
|
"""
|
|
event: Event
|
|
eventId: String
|
|
id: String!
|
|
membersCount: Int!
|
|
monetaryMass: numeric!
|
|
timestamp: timestamptz!
|
|
}
|
|
|
|
"""
|
|
aggregated selection of "universal_dividend"
|
|
"""
|
|
type UniversalDividendAggregate {
|
|
aggregate: UniversalDividendAggregateFields
|
|
nodes: [UniversalDividend!]!
|
|
}
|
|
|
|
"""
|
|
aggregate fields of "universal_dividend"
|
|
"""
|
|
type UniversalDividendAggregateFields {
|
|
avg: UniversalDividendAvgFields
|
|
count(columns: [UniversalDividendSelectColumn!], distinct: Boolean): Int!
|
|
max: UniversalDividendMaxFields
|
|
min: UniversalDividendMinFields
|
|
stddev: UniversalDividendStddevFields
|
|
stddevPop: UniversalDividendStddevPopFields
|
|
stddevSamp: UniversalDividendStddevSampFields
|
|
sum: UniversalDividendSumFields
|
|
varPop: UniversalDividendVarPopFields
|
|
varSamp: UniversalDividendVarSampFields
|
|
variance: UniversalDividendVarianceFields
|
|
}
|
|
|
|
"""
|
|
aggregate avg on columns
|
|
"""
|
|
type UniversalDividendAvgFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
"""
|
|
Boolean expression to filter rows from the table "universal_dividend". All fields are combined with a logical 'AND'.
|
|
"""
|
|
input UniversalDividendBoolExp {
|
|
_and: [UniversalDividendBoolExp!]
|
|
_not: UniversalDividendBoolExp
|
|
_or: [UniversalDividendBoolExp!]
|
|
amount: IntComparisonExp
|
|
blockNumber: IntComparisonExp
|
|
event: EventBoolExp
|
|
eventId: StringComparisonExp
|
|
id: StringComparisonExp
|
|
membersCount: IntComparisonExp
|
|
monetaryMass: NumericComparisonExp
|
|
timestamp: TimestamptzComparisonExp
|
|
}
|
|
|
|
"""
|
|
aggregate max on columns
|
|
"""
|
|
type UniversalDividendMaxFields {
|
|
amount: Int
|
|
blockNumber: Int
|
|
eventId: String
|
|
id: String
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
aggregate min on columns
|
|
"""
|
|
type UniversalDividendMinFields {
|
|
amount: Int
|
|
blockNumber: Int
|
|
eventId: String
|
|
id: String
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
Ordering options when selecting data from "universal_dividend".
|
|
"""
|
|
input UniversalDividendOrderBy {
|
|
amount: OrderBy
|
|
blockNumber: OrderBy
|
|
event: EventOrderBy
|
|
eventId: OrderBy
|
|
id: OrderBy
|
|
membersCount: OrderBy
|
|
monetaryMass: OrderBy
|
|
timestamp: OrderBy
|
|
}
|
|
|
|
"""
|
|
select columns of table "universal_dividend"
|
|
"""
|
|
enum UniversalDividendSelectColumn {
|
|
"""
|
|
column name
|
|
"""
|
|
amount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
blockNumber
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
eventId
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
id
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
membersCount
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
monetaryMass
|
|
|
|
"""
|
|
column name
|
|
"""
|
|
timestamp
|
|
}
|
|
|
|
"""
|
|
aggregate stddev on columns
|
|
"""
|
|
type UniversalDividendStddevFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
"""
|
|
aggregate stddevPop on columns
|
|
"""
|
|
type UniversalDividendStddevPopFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
"""
|
|
aggregate stddevSamp on columns
|
|
"""
|
|
type UniversalDividendStddevSampFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
"""
|
|
Streaming cursor of the table "universal_dividend"
|
|
"""
|
|
input UniversalDividendStreamCursorInput {
|
|
"""
|
|
Stream column input with initial value
|
|
"""
|
|
initialValue: UniversalDividendStreamCursorValueInput!
|
|
|
|
"""
|
|
cursor ordering
|
|
"""
|
|
ordering: CursorOrdering
|
|
}
|
|
|
|
"""
|
|
Initial value of the column from where the streaming should start
|
|
"""
|
|
input UniversalDividendStreamCursorValueInput {
|
|
amount: Int
|
|
blockNumber: Int
|
|
eventId: String
|
|
id: String
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
timestamp: timestamptz
|
|
}
|
|
|
|
"""
|
|
aggregate sum on columns
|
|
"""
|
|
type UniversalDividendSumFields {
|
|
amount: Int
|
|
blockNumber: Int
|
|
membersCount: Int
|
|
monetaryMass: numeric
|
|
}
|
|
|
|
"""
|
|
aggregate varPop on columns
|
|
"""
|
|
type UniversalDividendVarPopFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
"""
|
|
aggregate varSamp on columns
|
|
"""
|
|
type UniversalDividendVarSampFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
"""
|
|
aggregate variance on columns
|
|
"""
|
|
type UniversalDividendVarianceFields {
|
|
amount: Float
|
|
blockNumber: Float
|
|
membersCount: Float
|
|
monetaryMass: Float
|
|
}
|
|
|
|
input accountAggregateBoolExpCount {
|
|
arguments: [AccountSelectColumn!]
|
|
distinct: Boolean
|
|
filter: AccountBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
scalar bytea
|
|
|
|
input callAggregateBoolExpBool_and {
|
|
arguments: CallSelectColumnCallAggregateBoolExpBool_andArgumentsColumns!
|
|
distinct: Boolean
|
|
filter: CallBoolExp
|
|
predicate: BooleanComparisonExp!
|
|
}
|
|
|
|
input callAggregateBoolExpBool_or {
|
|
arguments: CallSelectColumnCallAggregateBoolExpBool_orArgumentsColumns!
|
|
distinct: Boolean
|
|
filter: CallBoolExp
|
|
predicate: BooleanComparisonExp!
|
|
}
|
|
|
|
input callAggregateBoolExpCount {
|
|
arguments: [CallSelectColumn!]
|
|
distinct: Boolean
|
|
filter: CallBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
input certAggregateBoolExpBool_and {
|
|
arguments: CertSelectColumnCertAggregateBoolExpBool_andArgumentsColumns!
|
|
distinct: Boolean
|
|
filter: CertBoolExp
|
|
predicate: BooleanComparisonExp!
|
|
}
|
|
|
|
input certAggregateBoolExpBool_or {
|
|
arguments: CertSelectColumnCertAggregateBoolExpBool_orArgumentsColumns!
|
|
distinct: Boolean
|
|
filter: CertBoolExp
|
|
predicate: BooleanComparisonExp!
|
|
}
|
|
|
|
input certAggregateBoolExpCount {
|
|
arguments: [CertSelectColumn!]
|
|
distinct: Boolean
|
|
filter: CertBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
input certEventAggregateBoolExpCount {
|
|
arguments: [CertEventSelectColumn!]
|
|
distinct: Boolean
|
|
filter: CertEventBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
input changeOwnerKeyAggregateBoolExpCount {
|
|
arguments: [ChangeOwnerKeySelectColumn!]
|
|
distinct: Boolean
|
|
filter: ChangeOwnerKeyBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
input eventAggregateBoolExpCount {
|
|
arguments: [EventSelectColumn!]
|
|
distinct: Boolean
|
|
filter: EventBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
input extrinsicAggregateBoolExpBool_and {
|
|
arguments: ExtrinsicSelectColumnExtrinsicAggregateBoolExpBool_andArgumentsColumns!
|
|
distinct: Boolean
|
|
filter: ExtrinsicBoolExp
|
|
predicate: BooleanComparisonExp!
|
|
}
|
|
|
|
input extrinsicAggregateBoolExpBool_or {
|
|
arguments: ExtrinsicSelectColumnExtrinsicAggregateBoolExpBool_orArgumentsColumns!
|
|
distinct: Boolean
|
|
filter: ExtrinsicBoolExp
|
|
predicate: BooleanComparisonExp!
|
|
}
|
|
|
|
input extrinsicAggregateBoolExpCount {
|
|
arguments: [ExtrinsicSelectColumn!]
|
|
distinct: Boolean
|
|
filter: ExtrinsicBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
input getUdHistoryArgs {
|
|
identity_row: identity_scalar
|
|
}
|
|
|
|
scalar identity_scalar
|
|
|
|
scalar jsonb
|
|
|
|
input membershipEventAggregateBoolExpCount {
|
|
arguments: [MembershipEventSelectColumn!]
|
|
distinct: Boolean
|
|
filter: MembershipEventBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
scalar numeric
|
|
|
|
type query_root {
|
|
"""
|
|
fetch data from the table: "account"
|
|
"""
|
|
account(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [AccountSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [AccountOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): [Account!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "account"
|
|
"""
|
|
accountAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [AccountSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [AccountOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): AccountAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "account" using primary key columns
|
|
"""
|
|
accountByPk(id: String!): Account
|
|
|
|
"""
|
|
fetch data from the table: "block"
|
|
"""
|
|
block(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [BlockSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [BlockOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: BlockBoolExp
|
|
): [Block!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "block"
|
|
"""
|
|
blockAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [BlockSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [BlockOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: BlockBoolExp
|
|
): BlockAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "block" using primary key columns
|
|
"""
|
|
blockByPk(id: String!): Block
|
|
|
|
"""
|
|
fetch data from the table: "call"
|
|
"""
|
|
call(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): [Call!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "call"
|
|
"""
|
|
callAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): CallAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "call" using primary key columns
|
|
"""
|
|
callByPk(id: String!): Call
|
|
|
|
"""
|
|
fetch data from the table: "cert"
|
|
"""
|
|
cert(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): [Cert!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "cert"
|
|
"""
|
|
certAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): CertAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "cert" using primary key columns
|
|
"""
|
|
certByPk(id: String!): Cert
|
|
|
|
"""
|
|
fetch data from the table: "cert_event"
|
|
"""
|
|
certEvent(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): [CertEvent!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "cert_event"
|
|
"""
|
|
certEventAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): CertEventAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "cert_event" using primary key columns
|
|
"""
|
|
certEventByPk(id: String!): CertEvent
|
|
|
|
"""
|
|
fetch data from the table: "change_owner_key"
|
|
"""
|
|
changeOwnerKey(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): [ChangeOwnerKey!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "change_owner_key"
|
|
"""
|
|
changeOwnerKeyAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): ChangeOwnerKeyAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "change_owner_key" using primary key columns
|
|
"""
|
|
changeOwnerKeyByPk(id: String!): ChangeOwnerKey
|
|
|
|
"""
|
|
fetch data from the table: "event"
|
|
"""
|
|
event(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): [Event!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "event"
|
|
"""
|
|
eventAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): EventAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "event" using primary key columns
|
|
"""
|
|
eventByPk(id: String!): Event
|
|
|
|
"""
|
|
fetch data from the table: "extrinsic"
|
|
"""
|
|
extrinsic(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ExtrinsicSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ExtrinsicOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): [Extrinsic!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "extrinsic"
|
|
"""
|
|
extrinsicAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ExtrinsicSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ExtrinsicOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): ExtrinsicAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "extrinsic" using primary key columns
|
|
"""
|
|
extrinsicByPk(id: String!): Extrinsic
|
|
|
|
"""
|
|
execute function "get_ud_history" which returns "ud_history"
|
|
"""
|
|
getUdHistory(
|
|
"""
|
|
input parameters for function "getUdHistory"
|
|
"""
|
|
args: getUdHistoryArgs!
|
|
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): [UdHistory!]!
|
|
|
|
"""
|
|
execute function "get_ud_history" and query aggregates on result of table type "ud_history"
|
|
"""
|
|
getUdHistoryAggregate(
|
|
"""
|
|
input parameters for function "getUdHistoryAggregate"
|
|
"""
|
|
args: getUdHistoryArgs!
|
|
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): UdHistoryAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "identity"
|
|
"""
|
|
identity(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [IdentitySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [IdentityOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: IdentityBoolExp
|
|
): [Identity!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "identity"
|
|
"""
|
|
identityAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [IdentitySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [IdentityOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: IdentityBoolExp
|
|
): IdentityAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "identity" using primary key columns
|
|
"""
|
|
identityByPk(id: String!): Identity
|
|
|
|
"""
|
|
fetch data from the table: "items_counter"
|
|
"""
|
|
itemsCounter(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ItemsCounterSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ItemsCounterOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ItemsCounterBoolExp
|
|
): [ItemsCounter!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "items_counter"
|
|
"""
|
|
itemsCounterAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ItemsCounterSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ItemsCounterOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ItemsCounterBoolExp
|
|
): ItemsCounterAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "items_counter" using primary key columns
|
|
"""
|
|
itemsCounterByPk(id: String!): ItemsCounter
|
|
|
|
"""
|
|
fetch data from the table: "membership_event"
|
|
"""
|
|
membershipEvent(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [MembershipEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [MembershipEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): [MembershipEvent!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "membership_event"
|
|
"""
|
|
membershipEventAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [MembershipEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [MembershipEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): MembershipEventAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "membership_event" using primary key columns
|
|
"""
|
|
membershipEventByPk(id: String!): MembershipEvent
|
|
|
|
"""
|
|
fetch data from the table: "smith_cert"
|
|
"""
|
|
smithCert(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): [SmithCert!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "smith_cert"
|
|
"""
|
|
smithCertAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): SmithCertAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "smith_cert" using primary key columns
|
|
"""
|
|
smithCertByPk(id: String!): SmithCert
|
|
|
|
"""
|
|
fetch data from the table: "transfer"
|
|
"""
|
|
transfer(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): [Transfer!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "transfer"
|
|
"""
|
|
transferAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): TransferAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "transfer" using primary key columns
|
|
"""
|
|
transferByPk(id: String!): Transfer
|
|
|
|
"""
|
|
fetch data from the table: "ud_history"
|
|
"""
|
|
udHistory(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): [UdHistory!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "ud_history"
|
|
"""
|
|
udHistoryAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): UdHistoryAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "ud_history" using primary key columns
|
|
"""
|
|
udHistoryByPk(id: String!): UdHistory
|
|
|
|
"""
|
|
fetch data from the table: "ud_reeval"
|
|
"""
|
|
udReeval(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdReevalSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdReevalOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdReevalBoolExp
|
|
): [UdReeval!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "ud_reeval"
|
|
"""
|
|
udReevalAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdReevalSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdReevalOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdReevalBoolExp
|
|
): UdReevalAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "ud_reeval" using primary key columns
|
|
"""
|
|
udReevalByPk(id: String!): UdReeval
|
|
|
|
"""
|
|
fetch data from the table: "universal_dividend"
|
|
"""
|
|
universalDividend(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UniversalDividendSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UniversalDividendOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UniversalDividendBoolExp
|
|
): [UniversalDividend!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "universal_dividend"
|
|
"""
|
|
universalDividendAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UniversalDividendSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UniversalDividendOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UniversalDividendBoolExp
|
|
): UniversalDividendAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "universal_dividend" using primary key columns
|
|
"""
|
|
universalDividendByPk(id: String!): UniversalDividend
|
|
}
|
|
|
|
input smithCertAggregateBoolExpCount {
|
|
arguments: [SmithCertSelectColumn!]
|
|
distinct: Boolean
|
|
filter: SmithCertBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|
|
|
|
type subscription_root {
|
|
"""
|
|
fetch data from the table: "account"
|
|
"""
|
|
account(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [AccountSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [AccountOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): [Account!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "account"
|
|
"""
|
|
accountAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [AccountSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [AccountOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): AccountAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "account" using primary key columns
|
|
"""
|
|
accountByPk(id: String!): Account
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "account"
|
|
"""
|
|
accountStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [AccountStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: AccountBoolExp
|
|
): [Account!]!
|
|
|
|
"""
|
|
fetch data from the table: "block"
|
|
"""
|
|
block(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [BlockSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [BlockOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: BlockBoolExp
|
|
): [Block!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "block"
|
|
"""
|
|
blockAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [BlockSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [BlockOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: BlockBoolExp
|
|
): BlockAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "block" using primary key columns
|
|
"""
|
|
blockByPk(id: String!): Block
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "block"
|
|
"""
|
|
blockStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [BlockStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: BlockBoolExp
|
|
): [Block!]!
|
|
|
|
"""
|
|
fetch data from the table: "call"
|
|
"""
|
|
call(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): [Call!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "call"
|
|
"""
|
|
callAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CallSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CallOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): CallAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "call" using primary key columns
|
|
"""
|
|
callByPk(id: String!): Call
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "call"
|
|
"""
|
|
callStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [CallStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CallBoolExp
|
|
): [Call!]!
|
|
|
|
"""
|
|
fetch data from the table: "cert"
|
|
"""
|
|
cert(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): [Cert!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "cert"
|
|
"""
|
|
certAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): CertAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "cert" using primary key columns
|
|
"""
|
|
certByPk(id: String!): Cert
|
|
|
|
"""
|
|
fetch data from the table: "cert_event"
|
|
"""
|
|
certEvent(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): [CertEvent!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "cert_event"
|
|
"""
|
|
certEventAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [CertEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [CertEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): CertEventAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "cert_event" using primary key columns
|
|
"""
|
|
certEventByPk(id: String!): CertEvent
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "cert_event"
|
|
"""
|
|
certEventStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [CertEventStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertEventBoolExp
|
|
): [CertEvent!]!
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "cert"
|
|
"""
|
|
certStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [CertStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: CertBoolExp
|
|
): [Cert!]!
|
|
|
|
"""
|
|
fetch data from the table: "change_owner_key"
|
|
"""
|
|
changeOwnerKey(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): [ChangeOwnerKey!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "change_owner_key"
|
|
"""
|
|
changeOwnerKeyAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ChangeOwnerKeySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ChangeOwnerKeyOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): ChangeOwnerKeyAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "change_owner_key" using primary key columns
|
|
"""
|
|
changeOwnerKeyByPk(id: String!): ChangeOwnerKey
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "change_owner_key"
|
|
"""
|
|
changeOwnerKeyStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [ChangeOwnerKeyStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ChangeOwnerKeyBoolExp
|
|
): [ChangeOwnerKey!]!
|
|
|
|
"""
|
|
fetch data from the table: "event"
|
|
"""
|
|
event(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): [Event!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "event"
|
|
"""
|
|
eventAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [EventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [EventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): EventAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "event" using primary key columns
|
|
"""
|
|
eventByPk(id: String!): Event
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "event"
|
|
"""
|
|
eventStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [EventStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: EventBoolExp
|
|
): [Event!]!
|
|
|
|
"""
|
|
fetch data from the table: "extrinsic"
|
|
"""
|
|
extrinsic(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ExtrinsicSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ExtrinsicOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): [Extrinsic!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "extrinsic"
|
|
"""
|
|
extrinsicAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ExtrinsicSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ExtrinsicOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): ExtrinsicAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "extrinsic" using primary key columns
|
|
"""
|
|
extrinsicByPk(id: String!): Extrinsic
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "extrinsic"
|
|
"""
|
|
extrinsicStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [ExtrinsicStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ExtrinsicBoolExp
|
|
): [Extrinsic!]!
|
|
|
|
"""
|
|
execute function "get_ud_history" which returns "ud_history"
|
|
"""
|
|
getUdHistory(
|
|
"""
|
|
input parameters for function "getUdHistory"
|
|
"""
|
|
args: getUdHistoryArgs!
|
|
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): [UdHistory!]!
|
|
|
|
"""
|
|
execute function "get_ud_history" and query aggregates on result of table type "ud_history"
|
|
"""
|
|
getUdHistoryAggregate(
|
|
"""
|
|
input parameters for function "getUdHistoryAggregate"
|
|
"""
|
|
args: getUdHistoryArgs!
|
|
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): UdHistoryAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "identity"
|
|
"""
|
|
identity(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [IdentitySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [IdentityOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: IdentityBoolExp
|
|
): [Identity!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "identity"
|
|
"""
|
|
identityAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [IdentitySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [IdentityOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: IdentityBoolExp
|
|
): IdentityAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "identity" using primary key columns
|
|
"""
|
|
identityByPk(id: String!): Identity
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "identity"
|
|
"""
|
|
identityStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [IdentityStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: IdentityBoolExp
|
|
): [Identity!]!
|
|
|
|
"""
|
|
fetch data from the table: "items_counter"
|
|
"""
|
|
itemsCounter(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ItemsCounterSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ItemsCounterOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ItemsCounterBoolExp
|
|
): [ItemsCounter!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "items_counter"
|
|
"""
|
|
itemsCounterAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [ItemsCounterSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [ItemsCounterOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ItemsCounterBoolExp
|
|
): ItemsCounterAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "items_counter" using primary key columns
|
|
"""
|
|
itemsCounterByPk(id: String!): ItemsCounter
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "items_counter"
|
|
"""
|
|
itemsCounterStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [ItemsCounterStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: ItemsCounterBoolExp
|
|
): [ItemsCounter!]!
|
|
|
|
"""
|
|
fetch data from the table: "membership_event"
|
|
"""
|
|
membershipEvent(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [MembershipEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [MembershipEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): [MembershipEvent!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "membership_event"
|
|
"""
|
|
membershipEventAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [MembershipEventSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [MembershipEventOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): MembershipEventAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "membership_event" using primary key columns
|
|
"""
|
|
membershipEventByPk(id: String!): MembershipEvent
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "membership_event"
|
|
"""
|
|
membershipEventStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [MembershipEventStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: MembershipEventBoolExp
|
|
): [MembershipEvent!]!
|
|
|
|
"""
|
|
fetch data from the table: "smith_cert"
|
|
"""
|
|
smithCert(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): [SmithCert!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "smith_cert"
|
|
"""
|
|
smithCertAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [SmithCertSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [SmithCertOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): SmithCertAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "smith_cert" using primary key columns
|
|
"""
|
|
smithCertByPk(id: String!): SmithCert
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "smith_cert"
|
|
"""
|
|
smithCertStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [SmithCertStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: SmithCertBoolExp
|
|
): [SmithCert!]!
|
|
|
|
"""
|
|
fetch data from the table: "transfer"
|
|
"""
|
|
transfer(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): [Transfer!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "transfer"
|
|
"""
|
|
transferAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [TransferSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [TransferOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): TransferAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "transfer" using primary key columns
|
|
"""
|
|
transferByPk(id: String!): Transfer
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "transfer"
|
|
"""
|
|
transferStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [TransferStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: TransferBoolExp
|
|
): [Transfer!]!
|
|
|
|
"""
|
|
fetch data from the table: "ud_history"
|
|
"""
|
|
udHistory(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): [UdHistory!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "ud_history"
|
|
"""
|
|
udHistoryAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdHistorySelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdHistoryOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): UdHistoryAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "ud_history" using primary key columns
|
|
"""
|
|
udHistoryByPk(id: String!): UdHistory
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "ud_history"
|
|
"""
|
|
udHistoryStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [UdHistoryStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdHistoryBoolExp
|
|
): [UdHistory!]!
|
|
|
|
"""
|
|
fetch data from the table: "ud_reeval"
|
|
"""
|
|
udReeval(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdReevalSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdReevalOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdReevalBoolExp
|
|
): [UdReeval!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "ud_reeval"
|
|
"""
|
|
udReevalAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UdReevalSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UdReevalOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdReevalBoolExp
|
|
): UdReevalAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "ud_reeval" using primary key columns
|
|
"""
|
|
udReevalByPk(id: String!): UdReeval
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "ud_reeval"
|
|
"""
|
|
udReevalStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [UdReevalStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UdReevalBoolExp
|
|
): [UdReeval!]!
|
|
|
|
"""
|
|
fetch data from the table: "universal_dividend"
|
|
"""
|
|
universalDividend(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UniversalDividendSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UniversalDividendOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UniversalDividendBoolExp
|
|
): [UniversalDividend!]!
|
|
|
|
"""
|
|
fetch aggregated fields from the table: "universal_dividend"
|
|
"""
|
|
universalDividendAggregate(
|
|
"""
|
|
distinct select on columns
|
|
"""
|
|
distinctOn: [UniversalDividendSelectColumn!]
|
|
|
|
"""
|
|
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
|
|
"""
|
|
orderBy: [UniversalDividendOrderBy!]
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UniversalDividendBoolExp
|
|
): UniversalDividendAggregate!
|
|
|
|
"""
|
|
fetch data from the table: "universal_dividend" using primary key columns
|
|
"""
|
|
universalDividendByPk(id: String!): UniversalDividend
|
|
|
|
"""
|
|
fetch data from the table in a streaming manner: "universal_dividend"
|
|
"""
|
|
universalDividendStream(
|
|
"""
|
|
maximum number of rows returned in a single batch
|
|
"""
|
|
batchSize: Int!
|
|
|
|
"""
|
|
cursor to stream the results returned by the query
|
|
"""
|
|
cursor: [UniversalDividendStreamCursorInput]!
|
|
|
|
"""
|
|
filter the rows returned
|
|
"""
|
|
where: UniversalDividendBoolExp
|
|
): [UniversalDividend!]!
|
|
}
|
|
|
|
scalar timestamptz
|
|
|
|
input transferAggregateBoolExpCount {
|
|
arguments: [TransferSelectColumn!]
|
|
distinct: Boolean
|
|
filter: TransferBoolExp
|
|
predicate: IntComparisonExp!
|
|
}
|