@requestnetwork/payment-detection 0.35.1-next.1714 → 0.35.1-next.1717

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/dist/erc20/escrow-info-retriever.d.ts +1 -0
  2. package/dist/erc20/escrow-info-retriever.d.ts.map +1 -1
  3. package/dist/erc20/escrow-info-retriever.js +5 -0
  4. package/dist/erc20/escrow-info-retriever.js.map +1 -1
  5. package/dist/thegraph/generated/graphql-superfluid.d.ts +1640 -29
  6. package/dist/thegraph/generated/graphql-superfluid.d.ts.map +1 -1
  7. package/dist/thegraph/generated/graphql-superfluid.js +145 -2
  8. package/dist/thegraph/generated/graphql-superfluid.js.map +1 -1
  9. package/package.json +7 -7
package/dist/thegraph/generated/graphql-superfluid.d.ts CHANGED
@@ -24,7 +24,7 @@ export declare type Scalars = {
24
24
  Bytes: any;
25
25
  };
26
26
  /**
27
- * Account: A HOL entity created for any addresses which interact with
27
+ * Account: A higher order entity created for any addresses which interact with
28
28
  * Superfluid contracts.
29
29
  */
30
30
  export declare type Account = {
@@ -47,7 +47,7 @@ export declare type Account = {
47
47
  accountTokenSnapshots: Array<AccountTokenSnapshot>;
48
48
  };
49
49
  /**
50
- * Account: A HOL entity created for any addresses which interact with
50
+ * Account: A higher order entity created for any addresses which interact with
51
51
  * Superfluid contracts.
52
52
  */
53
53
  export declare type AccountInflowsArgs = {
@@ -58,7 +58,7 @@ export declare type AccountInflowsArgs = {
58
58
  where?: Maybe<Stream_Filter>;
59
59
  };
60
60
  /**
61
- * Account: A HOL entity created for any addresses which interact with
61
+ * Account: A higher order entity created for any addresses which interact with
62
62
  * Superfluid contracts.
63
63
  */
64
64
  export declare type AccountOutflowsArgs = {
@@ -69,7 +69,7 @@ export declare type AccountOutflowsArgs = {
69
69
  where?: Maybe<Stream_Filter>;
70
70
  };
71
71
  /**
72
- * Account: A HOL entity created for any addresses which interact with
72
+ * Account: A higher order entity created for any addresses which interact with
73
73
  * Superfluid contracts.
74
74
  */
75
75
  export declare type AccountSubscriptionsArgs = {
@@ -80,7 +80,7 @@ export declare type AccountSubscriptionsArgs = {
80
80
  where?: Maybe<IndexSubscription_Filter>;
81
81
  };
82
82
  /**
83
- * Account: A HOL entity created for any addresses which interact with
83
+ * Account: A higher order entity created for any addresses which interact with
84
84
  * Superfluid contracts.
85
85
  */
86
86
  export declare type AccountPublishedIndexesArgs = {
@@ -91,7 +91,7 @@ export declare type AccountPublishedIndexesArgs = {
91
91
  where?: Maybe<Index_Filter>;
92
92
  };
93
93
  /**
94
- * Account: A HOL entity created for any addresses which interact with
94
+ * Account: A higher order entity created for any addresses which interact with
95
95
  * Superfluid contracts.
96
96
  */
97
97
  export declare type AccountSentTransferEventsArgs = {
@@ -102,7 +102,7 @@ export declare type AccountSentTransferEventsArgs = {
102
102
  where?: Maybe<TransferEvent_Filter>;
103
103
  };
104
104
  /**
105
- * Account: A HOL entity created for any addresses which interact with
105
+ * Account: A higher order entity created for any addresses which interact with
106
106
  * Superfluid contracts.
107
107
  */
108
108
  export declare type AccountReceivedTransferEventsArgs = {
@@ -113,7 +113,7 @@ export declare type AccountReceivedTransferEventsArgs = {
113
113
  where?: Maybe<TransferEvent_Filter>;
114
114
  };
115
115
  /**
116
- * Account: A HOL entity created for any addresses which interact with
116
+ * Account: A higher order entity created for any addresses which interact with
117
117
  * Superfluid contracts.
118
118
  */
119
119
  export declare type AccountTokenUpgradedEventsArgs = {
@@ -124,7 +124,7 @@ export declare type AccountTokenUpgradedEventsArgs = {
124
124
  where?: Maybe<TokenUpgradedEvent_Filter>;
125
125
  };
126
126
  /**
127
- * Account: A HOL entity created for any addresses which interact with
127
+ * Account: A higher order entity created for any addresses which interact with
128
128
  * Superfluid contracts.
129
129
  */
130
130
  export declare type AccountTokenDowngradedEventsArgs = {
@@ -135,7 +135,7 @@ export declare type AccountTokenDowngradedEventsArgs = {
135
135
  where?: Maybe<TokenDowngradedEvent_Filter>;
136
136
  };
137
137
  /**
138
- * Account: A HOL entity created for any addresses which interact with
138
+ * Account: A higher order entity created for any addresses which interact with
139
139
  * Superfluid contracts.
140
140
  */
141
141
  export declare type AccountAccountTokenSnapshotsArgs = {
@@ -155,6 +155,13 @@ export declare type AccountTokenSnapshot = {
155
155
  id: Scalars['ID'];
156
156
  updatedAtTimestamp: Scalars['BigInt'];
157
157
  updatedAtBlockNumber: Scalars['BigInt'];
158
+ /**
159
+ * isLiquidationEstimateOptimistic, If `totalSubscriptionsWithUnits > 0`, it is true.
160
+ * Optimistic means that it is the earliest time the user will be liquidated as they may receive ongoing distributions which aren't tracked by the subgraph
161
+ */
162
+ isLiquidationEstimateOptimistic: Scalars['Boolean'];
163
+ /** Optimistic liquidation estimation property. */
164
+ maybeCriticalAtTimestamp: Scalars['BigInt'];
158
165
  /** The number of currently open streams. */
159
166
  totalNumberOfActiveStreams: Scalars['Int'];
160
167
  /** The number of all-time closed streams. */
@@ -165,6 +172,8 @@ export declare type AccountTokenSnapshot = {
165
172
  totalApprovedSubscriptions: Scalars['Int'];
166
173
  /** Balance of `account` as of `updatedAtTimestamp`/`updatedAtBlock`. */
167
174
  balanceUntilUpdatedAt: Scalars['BigInt'];
175
+ /** The total deposit this account has held by the CFA agreement for `account` active streams. */
176
+ totalDeposit: Scalars['BigInt'];
168
177
  /** The total net flow rate of the `account` as of `updatedAtTimestamp`/`updatedAtBlock`. */
169
178
  totalNetFlowRate: Scalars['BigInt'];
170
179
  /** The total inflow rate (receive flowRate per second) of the `account`. */
@@ -180,7 +189,322 @@ export declare type AccountTokenSnapshot = {
180
189
  totalAmountTransferredUntilUpdatedAt: Scalars['BigInt'];
181
190
  account: Account;
182
191
  token: Token;
192
+ flowOperators: Array<FlowOperator>;
193
+ accountTokenSnapshotLogs: Array<AccountTokenSnapshotLog>;
183
194
  };
195
+ /**
196
+ * AccountTokenSnapshot: An aggregate entity which aggregates data on an account's
197
+ * interaction with a `token`.
198
+ */
199
+ export declare type AccountTokenSnapshotFlowOperatorsArgs = {
200
+ skip?: Maybe<Scalars['Int']>;
201
+ first?: Maybe<Scalars['Int']>;
202
+ orderBy?: Maybe<FlowOperator_OrderBy>;
203
+ orderDirection?: Maybe<OrderDirection>;
204
+ where?: Maybe<FlowOperator_Filter>;
205
+ };
206
+ /**
207
+ * AccountTokenSnapshot: An aggregate entity which aggregates data on an account's
208
+ * interaction with a `token`.
209
+ */
210
+ export declare type AccountTokenSnapshotAccountTokenSnapshotLogsArgs = {
211
+ skip?: Maybe<Scalars['Int']>;
212
+ first?: Maybe<Scalars['Int']>;
213
+ orderBy?: Maybe<AccountTokenSnapshotLog_OrderBy>;
214
+ orderDirection?: Maybe<OrderDirection>;
215
+ where?: Maybe<AccountTokenSnapshotLog_Filter>;
216
+ };
217
+ /** AccountTokenSnapshotLog: Historical entries of AccountTokenSnapshot updates. */
218
+ export declare type AccountTokenSnapshotLog = {
219
+ __typename?: 'AccountTokenSnapshotLog';
220
+ id: Scalars['ID'];
221
+ timestamp: Scalars['BigInt'];
222
+ blockNumber: Scalars['BigInt'];
223
+ transactionHash: Scalars['Bytes'];
224
+ logIndex: Scalars['BigInt'];
225
+ order: Scalars['BigInt'];
226
+ triggeredByEventName: Scalars['String'];
227
+ /** Optimistic liquidation estimation property. */
228
+ maybeCriticalAtTimestamp: Scalars['BigInt'];
229
+ /** The current (as of timestamp) number of currently open streams. */
230
+ totalNumberOfActiveStreams: Scalars['Int'];
231
+ /** The current (as of timestamp) number of all-time closed streams. */
232
+ totalNumberOfClosedStreams: Scalars['Int'];
233
+ /** The current (as of timestamp) number of subscriptions with units allocated to them tied to this `account`. */
234
+ totalSubscriptionsWithUnits: Scalars['Int'];
235
+ /** Counts all currently (as of timestamp) approved subscriptions whether or not they have units. */
236
+ totalApprovedSubscriptions: Scalars['Int'];
237
+ /** Balance of `account` as of `timestamp`/`block`. */
238
+ balance: Scalars['BigInt'];
239
+ /** The total (as of timestamp) deposit this account has held by the CFA agreement for `account` active streams. */
240
+ totalDeposit: Scalars['BigInt'];
241
+ /** The total (as of timestamp) net flow rate of the `account` as of `timestamp`/`block`. */
242
+ totalNetFlowRate: Scalars['BigInt'];
243
+ /** The total (as of timestamp) inflow rate (receive flowRate per second) of the `account`. */
244
+ totalInflowRate: Scalars['BigInt'];
245
+ /** The total (as of timestamp) outflow rate (send flowrate per second) of the `account`. */
246
+ totalOutflowRate: Scalars['BigInt'];
247
+ /**
248
+ * The total (as of timestamp) amount of `token` streamed to this `account` until
249
+ * the `timestamp`/`block`.
250
+ */
251
+ totalAmountStreamed: Scalars['BigInt'];
252
+ /** The total (as of timestamp) amount of `token` this `account` has transferred. */
253
+ totalAmountTransferred: Scalars['BigInt'];
254
+ account: Account;
255
+ token: Token;
256
+ accountTokenSnapshot: AccountTokenSnapshot;
257
+ };
258
+ export declare type AccountTokenSnapshotLog_Filter = {
259
+ id?: Maybe<Scalars['ID']>;
260
+ id_not?: Maybe<Scalars['ID']>;
261
+ id_gt?: Maybe<Scalars['ID']>;
262
+ id_lt?: Maybe<Scalars['ID']>;
263
+ id_gte?: Maybe<Scalars['ID']>;
264
+ id_lte?: Maybe<Scalars['ID']>;
265
+ id_in?: Maybe<Array<Scalars['ID']>>;
266
+ id_not_in?: Maybe<Array<Scalars['ID']>>;
267
+ timestamp?: Maybe<Scalars['BigInt']>;
268
+ timestamp_not?: Maybe<Scalars['BigInt']>;
269
+ timestamp_gt?: Maybe<Scalars['BigInt']>;
270
+ timestamp_lt?: Maybe<Scalars['BigInt']>;
271
+ timestamp_gte?: Maybe<Scalars['BigInt']>;
272
+ timestamp_lte?: Maybe<Scalars['BigInt']>;
273
+ timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
274
+ timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
275
+ blockNumber?: Maybe<Scalars['BigInt']>;
276
+ blockNumber_not?: Maybe<Scalars['BigInt']>;
277
+ blockNumber_gt?: Maybe<Scalars['BigInt']>;
278
+ blockNumber_lt?: Maybe<Scalars['BigInt']>;
279
+ blockNumber_gte?: Maybe<Scalars['BigInt']>;
280
+ blockNumber_lte?: Maybe<Scalars['BigInt']>;
281
+ blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
282
+ blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
283
+ transactionHash?: Maybe<Scalars['Bytes']>;
284
+ transactionHash_not?: Maybe<Scalars['Bytes']>;
285
+ transactionHash_in?: Maybe<Array<Scalars['Bytes']>>;
286
+ transactionHash_not_in?: Maybe<Array<Scalars['Bytes']>>;
287
+ transactionHash_contains?: Maybe<Scalars['Bytes']>;
288
+ transactionHash_not_contains?: Maybe<Scalars['Bytes']>;
289
+ logIndex?: Maybe<Scalars['BigInt']>;
290
+ logIndex_not?: Maybe<Scalars['BigInt']>;
291
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
292
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
293
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
294
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
295
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
296
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
297
+ order?: Maybe<Scalars['BigInt']>;
298
+ order_not?: Maybe<Scalars['BigInt']>;
299
+ order_gt?: Maybe<Scalars['BigInt']>;
300
+ order_lt?: Maybe<Scalars['BigInt']>;
301
+ order_gte?: Maybe<Scalars['BigInt']>;
302
+ order_lte?: Maybe<Scalars['BigInt']>;
303
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
304
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
305
+ triggeredByEventName?: Maybe<Scalars['String']>;
306
+ triggeredByEventName_not?: Maybe<Scalars['String']>;
307
+ triggeredByEventName_gt?: Maybe<Scalars['String']>;
308
+ triggeredByEventName_lt?: Maybe<Scalars['String']>;
309
+ triggeredByEventName_gte?: Maybe<Scalars['String']>;
310
+ triggeredByEventName_lte?: Maybe<Scalars['String']>;
311
+ triggeredByEventName_in?: Maybe<Array<Scalars['String']>>;
312
+ triggeredByEventName_not_in?: Maybe<Array<Scalars['String']>>;
313
+ triggeredByEventName_contains?: Maybe<Scalars['String']>;
314
+ triggeredByEventName_contains_nocase?: Maybe<Scalars['String']>;
315
+ triggeredByEventName_not_contains?: Maybe<Scalars['String']>;
316
+ triggeredByEventName_not_contains_nocase?: Maybe<Scalars['String']>;
317
+ triggeredByEventName_starts_with?: Maybe<Scalars['String']>;
318
+ triggeredByEventName_starts_with_nocase?: Maybe<Scalars['String']>;
319
+ triggeredByEventName_not_starts_with?: Maybe<Scalars['String']>;
320
+ triggeredByEventName_not_starts_with_nocase?: Maybe<Scalars['String']>;
321
+ triggeredByEventName_ends_with?: Maybe<Scalars['String']>;
322
+ triggeredByEventName_ends_with_nocase?: Maybe<Scalars['String']>;
323
+ triggeredByEventName_not_ends_with?: Maybe<Scalars['String']>;
324
+ triggeredByEventName_not_ends_with_nocase?: Maybe<Scalars['String']>;
325
+ maybeCriticalAtTimestamp?: Maybe<Scalars['BigInt']>;
326
+ maybeCriticalAtTimestamp_not?: Maybe<Scalars['BigInt']>;
327
+ maybeCriticalAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
328
+ maybeCriticalAtTimestamp_lt?: Maybe<Scalars['BigInt']>;
329
+ maybeCriticalAtTimestamp_gte?: Maybe<Scalars['BigInt']>;
330
+ maybeCriticalAtTimestamp_lte?: Maybe<Scalars['BigInt']>;
331
+ maybeCriticalAtTimestamp_in?: Maybe<Array<Scalars['BigInt']>>;
332
+ maybeCriticalAtTimestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
333
+ totalNumberOfActiveStreams?: Maybe<Scalars['Int']>;
334
+ totalNumberOfActiveStreams_not?: Maybe<Scalars['Int']>;
335
+ totalNumberOfActiveStreams_gt?: Maybe<Scalars['Int']>;
336
+ totalNumberOfActiveStreams_lt?: Maybe<Scalars['Int']>;
337
+ totalNumberOfActiveStreams_gte?: Maybe<Scalars['Int']>;
338
+ totalNumberOfActiveStreams_lte?: Maybe<Scalars['Int']>;
339
+ totalNumberOfActiveStreams_in?: Maybe<Array<Scalars['Int']>>;
340
+ totalNumberOfActiveStreams_not_in?: Maybe<Array<Scalars['Int']>>;
341
+ totalNumberOfClosedStreams?: Maybe<Scalars['Int']>;
342
+ totalNumberOfClosedStreams_not?: Maybe<Scalars['Int']>;
343
+ totalNumberOfClosedStreams_gt?: Maybe<Scalars['Int']>;
344
+ totalNumberOfClosedStreams_lt?: Maybe<Scalars['Int']>;
345
+ totalNumberOfClosedStreams_gte?: Maybe<Scalars['Int']>;
346
+ totalNumberOfClosedStreams_lte?: Maybe<Scalars['Int']>;
347
+ totalNumberOfClosedStreams_in?: Maybe<Array<Scalars['Int']>>;
348
+ totalNumberOfClosedStreams_not_in?: Maybe<Array<Scalars['Int']>>;
349
+ totalSubscriptionsWithUnits?: Maybe<Scalars['Int']>;
350
+ totalSubscriptionsWithUnits_not?: Maybe<Scalars['Int']>;
351
+ totalSubscriptionsWithUnits_gt?: Maybe<Scalars['Int']>;
352
+ totalSubscriptionsWithUnits_lt?: Maybe<Scalars['Int']>;
353
+ totalSubscriptionsWithUnits_gte?: Maybe<Scalars['Int']>;
354
+ totalSubscriptionsWithUnits_lte?: Maybe<Scalars['Int']>;
355
+ totalSubscriptionsWithUnits_in?: Maybe<Array<Scalars['Int']>>;
356
+ totalSubscriptionsWithUnits_not_in?: Maybe<Array<Scalars['Int']>>;
357
+ totalApprovedSubscriptions?: Maybe<Scalars['Int']>;
358
+ totalApprovedSubscriptions_not?: Maybe<Scalars['Int']>;
359
+ totalApprovedSubscriptions_gt?: Maybe<Scalars['Int']>;
360
+ totalApprovedSubscriptions_lt?: Maybe<Scalars['Int']>;
361
+ totalApprovedSubscriptions_gte?: Maybe<Scalars['Int']>;
362
+ totalApprovedSubscriptions_lte?: Maybe<Scalars['Int']>;
363
+ totalApprovedSubscriptions_in?: Maybe<Array<Scalars['Int']>>;
364
+ totalApprovedSubscriptions_not_in?: Maybe<Array<Scalars['Int']>>;
365
+ balance?: Maybe<Scalars['BigInt']>;
366
+ balance_not?: Maybe<Scalars['BigInt']>;
367
+ balance_gt?: Maybe<Scalars['BigInt']>;
368
+ balance_lt?: Maybe<Scalars['BigInt']>;
369
+ balance_gte?: Maybe<Scalars['BigInt']>;
370
+ balance_lte?: Maybe<Scalars['BigInt']>;
371
+ balance_in?: Maybe<Array<Scalars['BigInt']>>;
372
+ balance_not_in?: Maybe<Array<Scalars['BigInt']>>;
373
+ totalDeposit?: Maybe<Scalars['BigInt']>;
374
+ totalDeposit_not?: Maybe<Scalars['BigInt']>;
375
+ totalDeposit_gt?: Maybe<Scalars['BigInt']>;
376
+ totalDeposit_lt?: Maybe<Scalars['BigInt']>;
377
+ totalDeposit_gte?: Maybe<Scalars['BigInt']>;
378
+ totalDeposit_lte?: Maybe<Scalars['BigInt']>;
379
+ totalDeposit_in?: Maybe<Array<Scalars['BigInt']>>;
380
+ totalDeposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
381
+ totalNetFlowRate?: Maybe<Scalars['BigInt']>;
382
+ totalNetFlowRate_not?: Maybe<Scalars['BigInt']>;
383
+ totalNetFlowRate_gt?: Maybe<Scalars['BigInt']>;
384
+ totalNetFlowRate_lt?: Maybe<Scalars['BigInt']>;
385
+ totalNetFlowRate_gte?: Maybe<Scalars['BigInt']>;
386
+ totalNetFlowRate_lte?: Maybe<Scalars['BigInt']>;
387
+ totalNetFlowRate_in?: Maybe<Array<Scalars['BigInt']>>;
388
+ totalNetFlowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
389
+ totalInflowRate?: Maybe<Scalars['BigInt']>;
390
+ totalInflowRate_not?: Maybe<Scalars['BigInt']>;
391
+ totalInflowRate_gt?: Maybe<Scalars['BigInt']>;
392
+ totalInflowRate_lt?: Maybe<Scalars['BigInt']>;
393
+ totalInflowRate_gte?: Maybe<Scalars['BigInt']>;
394
+ totalInflowRate_lte?: Maybe<Scalars['BigInt']>;
395
+ totalInflowRate_in?: Maybe<Array<Scalars['BigInt']>>;
396
+ totalInflowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
397
+ totalOutflowRate?: Maybe<Scalars['BigInt']>;
398
+ totalOutflowRate_not?: Maybe<Scalars['BigInt']>;
399
+ totalOutflowRate_gt?: Maybe<Scalars['BigInt']>;
400
+ totalOutflowRate_lt?: Maybe<Scalars['BigInt']>;
401
+ totalOutflowRate_gte?: Maybe<Scalars['BigInt']>;
402
+ totalOutflowRate_lte?: Maybe<Scalars['BigInt']>;
403
+ totalOutflowRate_in?: Maybe<Array<Scalars['BigInt']>>;
404
+ totalOutflowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
405
+ totalAmountStreamed?: Maybe<Scalars['BigInt']>;
406
+ totalAmountStreamed_not?: Maybe<Scalars['BigInt']>;
407
+ totalAmountStreamed_gt?: Maybe<Scalars['BigInt']>;
408
+ totalAmountStreamed_lt?: Maybe<Scalars['BigInt']>;
409
+ totalAmountStreamed_gte?: Maybe<Scalars['BigInt']>;
410
+ totalAmountStreamed_lte?: Maybe<Scalars['BigInt']>;
411
+ totalAmountStreamed_in?: Maybe<Array<Scalars['BigInt']>>;
412
+ totalAmountStreamed_not_in?: Maybe<Array<Scalars['BigInt']>>;
413
+ totalAmountTransferred?: Maybe<Scalars['BigInt']>;
414
+ totalAmountTransferred_not?: Maybe<Scalars['BigInt']>;
415
+ totalAmountTransferred_gt?: Maybe<Scalars['BigInt']>;
416
+ totalAmountTransferred_lt?: Maybe<Scalars['BigInt']>;
417
+ totalAmountTransferred_gte?: Maybe<Scalars['BigInt']>;
418
+ totalAmountTransferred_lte?: Maybe<Scalars['BigInt']>;
419
+ totalAmountTransferred_in?: Maybe<Array<Scalars['BigInt']>>;
420
+ totalAmountTransferred_not_in?: Maybe<Array<Scalars['BigInt']>>;
421
+ account?: Maybe<Scalars['String']>;
422
+ account_not?: Maybe<Scalars['String']>;
423
+ account_gt?: Maybe<Scalars['String']>;
424
+ account_lt?: Maybe<Scalars['String']>;
425
+ account_gte?: Maybe<Scalars['String']>;
426
+ account_lte?: Maybe<Scalars['String']>;
427
+ account_in?: Maybe<Array<Scalars['String']>>;
428
+ account_not_in?: Maybe<Array<Scalars['String']>>;
429
+ account_contains?: Maybe<Scalars['String']>;
430
+ account_contains_nocase?: Maybe<Scalars['String']>;
431
+ account_not_contains?: Maybe<Scalars['String']>;
432
+ account_not_contains_nocase?: Maybe<Scalars['String']>;
433
+ account_starts_with?: Maybe<Scalars['String']>;
434
+ account_starts_with_nocase?: Maybe<Scalars['String']>;
435
+ account_not_starts_with?: Maybe<Scalars['String']>;
436
+ account_not_starts_with_nocase?: Maybe<Scalars['String']>;
437
+ account_ends_with?: Maybe<Scalars['String']>;
438
+ account_ends_with_nocase?: Maybe<Scalars['String']>;
439
+ account_not_ends_with?: Maybe<Scalars['String']>;
440
+ account_not_ends_with_nocase?: Maybe<Scalars['String']>;
441
+ token?: Maybe<Scalars['String']>;
442
+ token_not?: Maybe<Scalars['String']>;
443
+ token_gt?: Maybe<Scalars['String']>;
444
+ token_lt?: Maybe<Scalars['String']>;
445
+ token_gte?: Maybe<Scalars['String']>;
446
+ token_lte?: Maybe<Scalars['String']>;
447
+ token_in?: Maybe<Array<Scalars['String']>>;
448
+ token_not_in?: Maybe<Array<Scalars['String']>>;
449
+ token_contains?: Maybe<Scalars['String']>;
450
+ token_contains_nocase?: Maybe<Scalars['String']>;
451
+ token_not_contains?: Maybe<Scalars['String']>;
452
+ token_not_contains_nocase?: Maybe<Scalars['String']>;
453
+ token_starts_with?: Maybe<Scalars['String']>;
454
+ token_starts_with_nocase?: Maybe<Scalars['String']>;
455
+ token_not_starts_with?: Maybe<Scalars['String']>;
456
+ token_not_starts_with_nocase?: Maybe<Scalars['String']>;
457
+ token_ends_with?: Maybe<Scalars['String']>;
458
+ token_ends_with_nocase?: Maybe<Scalars['String']>;
459
+ token_not_ends_with?: Maybe<Scalars['String']>;
460
+ token_not_ends_with_nocase?: Maybe<Scalars['String']>;
461
+ accountTokenSnapshot?: Maybe<Scalars['String']>;
462
+ accountTokenSnapshot_not?: Maybe<Scalars['String']>;
463
+ accountTokenSnapshot_gt?: Maybe<Scalars['String']>;
464
+ accountTokenSnapshot_lt?: Maybe<Scalars['String']>;
465
+ accountTokenSnapshot_gte?: Maybe<Scalars['String']>;
466
+ accountTokenSnapshot_lte?: Maybe<Scalars['String']>;
467
+ accountTokenSnapshot_in?: Maybe<Array<Scalars['String']>>;
468
+ accountTokenSnapshot_not_in?: Maybe<Array<Scalars['String']>>;
469
+ accountTokenSnapshot_contains?: Maybe<Scalars['String']>;
470
+ accountTokenSnapshot_contains_nocase?: Maybe<Scalars['String']>;
471
+ accountTokenSnapshot_not_contains?: Maybe<Scalars['String']>;
472
+ accountTokenSnapshot_not_contains_nocase?: Maybe<Scalars['String']>;
473
+ accountTokenSnapshot_starts_with?: Maybe<Scalars['String']>;
474
+ accountTokenSnapshot_starts_with_nocase?: Maybe<Scalars['String']>;
475
+ accountTokenSnapshot_not_starts_with?: Maybe<Scalars['String']>;
476
+ accountTokenSnapshot_not_starts_with_nocase?: Maybe<Scalars['String']>;
477
+ accountTokenSnapshot_ends_with?: Maybe<Scalars['String']>;
478
+ accountTokenSnapshot_ends_with_nocase?: Maybe<Scalars['String']>;
479
+ accountTokenSnapshot_not_ends_with?: Maybe<Scalars['String']>;
480
+ accountTokenSnapshot_not_ends_with_nocase?: Maybe<Scalars['String']>;
481
+ /** Filter for the block changed event. */
482
+ _change_block?: Maybe<BlockChangedFilter>;
483
+ };
484
+ export declare enum AccountTokenSnapshotLog_OrderBy {
485
+ Id = "id",
486
+ Timestamp = "timestamp",
487
+ BlockNumber = "blockNumber",
488
+ TransactionHash = "transactionHash",
489
+ LogIndex = "logIndex",
490
+ Order = "order",
491
+ TriggeredByEventName = "triggeredByEventName",
492
+ MaybeCriticalAtTimestamp = "maybeCriticalAtTimestamp",
493
+ TotalNumberOfActiveStreams = "totalNumberOfActiveStreams",
494
+ TotalNumberOfClosedStreams = "totalNumberOfClosedStreams",
495
+ TotalSubscriptionsWithUnits = "totalSubscriptionsWithUnits",
496
+ TotalApprovedSubscriptions = "totalApprovedSubscriptions",
497
+ Balance = "balance",
498
+ TotalDeposit = "totalDeposit",
499
+ TotalNetFlowRate = "totalNetFlowRate",
500
+ TotalInflowRate = "totalInflowRate",
501
+ TotalOutflowRate = "totalOutflowRate",
502
+ TotalAmountStreamed = "totalAmountStreamed",
503
+ TotalAmountTransferred = "totalAmountTransferred",
504
+ Account = "account",
505
+ Token = "token",
506
+ AccountTokenSnapshot = "accountTokenSnapshot"
507
+ }
184
508
  export declare type AccountTokenSnapshot_Filter = {
185
509
  id?: Maybe<Scalars['ID']>;
186
510
  id_not?: Maybe<Scalars['ID']>;
@@ -206,6 +530,18 @@ export declare type AccountTokenSnapshot_Filter = {
206
530
  updatedAtBlockNumber_lte?: Maybe<Scalars['BigInt']>;
207
531
  updatedAtBlockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
208
532
  updatedAtBlockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
533
+ isLiquidationEstimateOptimistic?: Maybe<Scalars['Boolean']>;
534
+ isLiquidationEstimateOptimistic_not?: Maybe<Scalars['Boolean']>;
535
+ isLiquidationEstimateOptimistic_in?: Maybe<Array<Scalars['Boolean']>>;
536
+ isLiquidationEstimateOptimistic_not_in?: Maybe<Array<Scalars['Boolean']>>;
537
+ maybeCriticalAtTimestamp?: Maybe<Scalars['BigInt']>;
538
+ maybeCriticalAtTimestamp_not?: Maybe<Scalars['BigInt']>;
539
+ maybeCriticalAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
540
+ maybeCriticalAtTimestamp_lt?: Maybe<Scalars['BigInt']>;
541
+ maybeCriticalAtTimestamp_gte?: Maybe<Scalars['BigInt']>;
542
+ maybeCriticalAtTimestamp_lte?: Maybe<Scalars['BigInt']>;
543
+ maybeCriticalAtTimestamp_in?: Maybe<Array<Scalars['BigInt']>>;
544
+ maybeCriticalAtTimestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
209
545
  totalNumberOfActiveStreams?: Maybe<Scalars['Int']>;
210
546
  totalNumberOfActiveStreams_not?: Maybe<Scalars['Int']>;
211
547
  totalNumberOfActiveStreams_gt?: Maybe<Scalars['Int']>;
@@ -246,6 +582,14 @@ export declare type AccountTokenSnapshot_Filter = {
246
582
  balanceUntilUpdatedAt_lte?: Maybe<Scalars['BigInt']>;
247
583
  balanceUntilUpdatedAt_in?: Maybe<Array<Scalars['BigInt']>>;
248
584
  balanceUntilUpdatedAt_not_in?: Maybe<Array<Scalars['BigInt']>>;
585
+ totalDeposit?: Maybe<Scalars['BigInt']>;
586
+ totalDeposit_not?: Maybe<Scalars['BigInt']>;
587
+ totalDeposit_gt?: Maybe<Scalars['BigInt']>;
588
+ totalDeposit_lt?: Maybe<Scalars['BigInt']>;
589
+ totalDeposit_gte?: Maybe<Scalars['BigInt']>;
590
+ totalDeposit_lte?: Maybe<Scalars['BigInt']>;
591
+ totalDeposit_in?: Maybe<Array<Scalars['BigInt']>>;
592
+ totalDeposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
249
593
  totalNetFlowRate?: Maybe<Scalars['BigInt']>;
250
594
  totalNetFlowRate_not?: Maybe<Scalars['BigInt']>;
251
595
  totalNetFlowRate_gt?: Maybe<Scalars['BigInt']>;
@@ -333,18 +677,23 @@ export declare enum AccountTokenSnapshot_OrderBy {
333
677
  Id = "id",
334
678
  UpdatedAtTimestamp = "updatedAtTimestamp",
335
679
  UpdatedAtBlockNumber = "updatedAtBlockNumber",
680
+ IsLiquidationEstimateOptimistic = "isLiquidationEstimateOptimistic",
681
+ MaybeCriticalAtTimestamp = "maybeCriticalAtTimestamp",
336
682
  TotalNumberOfActiveStreams = "totalNumberOfActiveStreams",
337
683
  TotalNumberOfClosedStreams = "totalNumberOfClosedStreams",
338
684
  TotalSubscriptionsWithUnits = "totalSubscriptionsWithUnits",
339
685
  TotalApprovedSubscriptions = "totalApprovedSubscriptions",
340
686
  BalanceUntilUpdatedAt = "balanceUntilUpdatedAt",
687
+ TotalDeposit = "totalDeposit",
341
688
  TotalNetFlowRate = "totalNetFlowRate",
342
689
  TotalInflowRate = "totalInflowRate",
343
690
  TotalOutflowRate = "totalOutflowRate",
344
691
  TotalAmountStreamedUntilUpdatedAt = "totalAmountStreamedUntilUpdatedAt",
345
692
  TotalAmountTransferredUntilUpdatedAt = "totalAmountTransferredUntilUpdatedAt",
346
693
  Account = "account",
347
- Token = "token"
694
+ Token = "token",
695
+ FlowOperators = "flowOperators",
696
+ AccountTokenSnapshotLogs = "accountTokenSnapshotLogs"
348
697
  }
349
698
  export declare type Account_Filter = {
350
699
  id?: Maybe<Scalars['ID']>;
@@ -420,6 +769,8 @@ export declare type AgreementClassRegisteredEvent = Event & {
420
769
  /** Empty addresses array. */
421
770
  addresses: Array<Scalars['Bytes']>;
422
771
  blockNumber: Scalars['BigInt'];
772
+ logIndex: Scalars['BigInt'];
773
+ order: Scalars['BigInt'];
423
774
  agreementType: Scalars['Bytes'];
424
775
  code: Scalars['Bytes'];
425
776
  };
@@ -480,6 +831,22 @@ export declare type AgreementClassRegisteredEvent_Filter = {
480
831
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
481
832
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
482
833
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
834
+ logIndex?: Maybe<Scalars['BigInt']>;
835
+ logIndex_not?: Maybe<Scalars['BigInt']>;
836
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
837
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
838
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
839
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
840
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
841
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
842
+ order?: Maybe<Scalars['BigInt']>;
843
+ order_not?: Maybe<Scalars['BigInt']>;
844
+ order_gt?: Maybe<Scalars['BigInt']>;
845
+ order_lt?: Maybe<Scalars['BigInt']>;
846
+ order_gte?: Maybe<Scalars['BigInt']>;
847
+ order_lte?: Maybe<Scalars['BigInt']>;
848
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
849
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
483
850
  agreementType?: Maybe<Scalars['Bytes']>;
484
851
  agreementType_not?: Maybe<Scalars['Bytes']>;
485
852
  agreementType_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -502,6 +869,8 @@ export declare enum AgreementClassRegisteredEvent_OrderBy {
502
869
  Name = "name",
503
870
  Addresses = "addresses",
504
871
  BlockNumber = "blockNumber",
872
+ LogIndex = "logIndex",
873
+ Order = "order",
505
874
  AgreementType = "agreementType",
506
875
  Code = "code"
507
876
  }
@@ -514,6 +883,8 @@ export declare type AgreementClassUpdatedEvent = Event & {
514
883
  /** Empty addresses array. */
515
884
  addresses: Array<Scalars['Bytes']>;
516
885
  blockNumber: Scalars['BigInt'];
886
+ logIndex: Scalars['BigInt'];
887
+ order: Scalars['BigInt'];
517
888
  agreementType: Scalars['Bytes'];
518
889
  code: Scalars['Bytes'];
519
890
  };
@@ -574,6 +945,22 @@ export declare type AgreementClassUpdatedEvent_Filter = {
574
945
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
575
946
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
576
947
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
948
+ logIndex?: Maybe<Scalars['BigInt']>;
949
+ logIndex_not?: Maybe<Scalars['BigInt']>;
950
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
951
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
952
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
953
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
954
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
955
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
956
+ order?: Maybe<Scalars['BigInt']>;
957
+ order_not?: Maybe<Scalars['BigInt']>;
958
+ order_gt?: Maybe<Scalars['BigInt']>;
959
+ order_lt?: Maybe<Scalars['BigInt']>;
960
+ order_gte?: Maybe<Scalars['BigInt']>;
961
+ order_lte?: Maybe<Scalars['BigInt']>;
962
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
963
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
577
964
  agreementType?: Maybe<Scalars['Bytes']>;
578
965
  agreementType_not?: Maybe<Scalars['Bytes']>;
579
966
  agreementType_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -596,6 +983,8 @@ export declare enum AgreementClassUpdatedEvent_OrderBy {
596
983
  Name = "name",
597
984
  Addresses = "addresses",
598
985
  BlockNumber = "blockNumber",
986
+ LogIndex = "logIndex",
987
+ Order = "order",
599
988
  AgreementType = "agreementType",
600
989
  Code = "code"
601
990
  }
@@ -608,6 +997,8 @@ export declare type AgreementLiquidatedByEvent = Event & {
608
997
  /** Holds the token, liquidatorAccount, penaltyAccount and bondAccount addresses. */
609
998
  addresses: Array<Scalars['Bytes']>;
610
999
  blockNumber: Scalars['BigInt'];
1000
+ logIndex: Scalars['BigInt'];
1001
+ order: Scalars['BigInt'];
611
1002
  token: Scalars['Bytes'];
612
1003
  liquidatorAccount: Scalars['Bytes'];
613
1004
  agreementClass: Scalars['Bytes'];
@@ -674,6 +1065,22 @@ export declare type AgreementLiquidatedByEvent_Filter = {
674
1065
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
675
1066
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
676
1067
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1068
+ logIndex?: Maybe<Scalars['BigInt']>;
1069
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1070
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1071
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1072
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1073
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1074
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1075
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1076
+ order?: Maybe<Scalars['BigInt']>;
1077
+ order_not?: Maybe<Scalars['BigInt']>;
1078
+ order_gt?: Maybe<Scalars['BigInt']>;
1079
+ order_lt?: Maybe<Scalars['BigInt']>;
1080
+ order_gte?: Maybe<Scalars['BigInt']>;
1081
+ order_lte?: Maybe<Scalars['BigInt']>;
1082
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1083
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
677
1084
  token?: Maybe<Scalars['Bytes']>;
678
1085
  token_not?: Maybe<Scalars['Bytes']>;
679
1086
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -736,6 +1143,8 @@ export declare enum AgreementLiquidatedByEvent_OrderBy {
736
1143
  Name = "name",
737
1144
  Addresses = "addresses",
738
1145
  BlockNumber = "blockNumber",
1146
+ LogIndex = "logIndex",
1147
+ Order = "order",
739
1148
  Token = "token",
740
1149
  LiquidatorAccount = "liquidatorAccount",
741
1150
  AgreementClass = "agreementClass",
@@ -754,6 +1163,8 @@ export declare type AgreementLiquidatedV2Event = Event & {
754
1163
  /** Holds the token, liquidatorAccount, targetAccount and rewardAccount addresses. */
755
1164
  addresses: Array<Scalars['Bytes']>;
756
1165
  blockNumber: Scalars['BigInt'];
1166
+ logIndex: Scalars['BigInt'];
1167
+ order: Scalars['BigInt'];
757
1168
  token: Scalars['Bytes'];
758
1169
  liquidatorAccount: Scalars['Bytes'];
759
1170
  agreementClass: Scalars['Bytes'];
@@ -822,6 +1233,22 @@ export declare type AgreementLiquidatedV2Event_Filter = {
822
1233
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
823
1234
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
824
1235
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1236
+ logIndex?: Maybe<Scalars['BigInt']>;
1237
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1238
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1239
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1240
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1241
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1242
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1243
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1244
+ order?: Maybe<Scalars['BigInt']>;
1245
+ order_not?: Maybe<Scalars['BigInt']>;
1246
+ order_gt?: Maybe<Scalars['BigInt']>;
1247
+ order_lt?: Maybe<Scalars['BigInt']>;
1248
+ order_gte?: Maybe<Scalars['BigInt']>;
1249
+ order_lte?: Maybe<Scalars['BigInt']>;
1250
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1251
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
825
1252
  token?: Maybe<Scalars['Bytes']>;
826
1253
  token_not?: Maybe<Scalars['Bytes']>;
827
1254
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -900,6 +1327,8 @@ export declare enum AgreementLiquidatedV2Event_OrderBy {
900
1327
  Name = "name",
901
1328
  Addresses = "addresses",
902
1329
  BlockNumber = "blockNumber",
1330
+ LogIndex = "logIndex",
1331
+ Order = "order",
903
1332
  Token = "token",
904
1333
  LiquidatorAccount = "liquidatorAccount",
905
1334
  AgreementClass = "agreementClass",
@@ -920,6 +1349,8 @@ export declare type AppRegisteredEvent = Event & {
920
1349
  /** Empty addresses array. */
921
1350
  addresses: Array<Scalars['Bytes']>;
922
1351
  blockNumber: Scalars['BigInt'];
1352
+ logIndex: Scalars['BigInt'];
1353
+ order: Scalars['BigInt'];
923
1354
  app: Scalars['Bytes'];
924
1355
  };
925
1356
  export declare type AppRegisteredEvent_Filter = {
@@ -979,6 +1410,22 @@ export declare type AppRegisteredEvent_Filter = {
979
1410
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
980
1411
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
981
1412
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1413
+ logIndex?: Maybe<Scalars['BigInt']>;
1414
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1415
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1416
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1417
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1418
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1419
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1420
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1421
+ order?: Maybe<Scalars['BigInt']>;
1422
+ order_not?: Maybe<Scalars['BigInt']>;
1423
+ order_gt?: Maybe<Scalars['BigInt']>;
1424
+ order_lt?: Maybe<Scalars['BigInt']>;
1425
+ order_gte?: Maybe<Scalars['BigInt']>;
1426
+ order_lte?: Maybe<Scalars['BigInt']>;
1427
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1428
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
982
1429
  app?: Maybe<Scalars['Bytes']>;
983
1430
  app_not?: Maybe<Scalars['Bytes']>;
984
1431
  app_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -995,6 +1442,8 @@ export declare enum AppRegisteredEvent_OrderBy {
995
1442
  Name = "name",
996
1443
  Addresses = "addresses",
997
1444
  BlockNumber = "blockNumber",
1445
+ LogIndex = "logIndex",
1446
+ Order = "order",
998
1447
  App = "app"
999
1448
  }
1000
1449
  export declare type BlockChangedFilter = {
@@ -1014,6 +1463,8 @@ export declare type BurnedEvent = Event & {
1014
1463
  /** Holds the token and from addresses. */
1015
1464
  addresses: Array<Scalars['Bytes']>;
1016
1465
  blockNumber: Scalars['BigInt'];
1466
+ logIndex: Scalars['BigInt'];
1467
+ order: Scalars['BigInt'];
1017
1468
  operator: Scalars['Bytes'];
1018
1469
  from: Scalars['Bytes'];
1019
1470
  amount: Scalars['BigInt'];
@@ -1077,6 +1528,22 @@ export declare type BurnedEvent_Filter = {
1077
1528
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1078
1529
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1079
1530
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1531
+ logIndex?: Maybe<Scalars['BigInt']>;
1532
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1533
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1534
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1535
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1536
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1537
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1538
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1539
+ order?: Maybe<Scalars['BigInt']>;
1540
+ order_not?: Maybe<Scalars['BigInt']>;
1541
+ order_gt?: Maybe<Scalars['BigInt']>;
1542
+ order_lt?: Maybe<Scalars['BigInt']>;
1543
+ order_gte?: Maybe<Scalars['BigInt']>;
1544
+ order_lte?: Maybe<Scalars['BigInt']>;
1545
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1546
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1080
1547
  operator?: Maybe<Scalars['Bytes']>;
1081
1548
  operator_not?: Maybe<Scalars['Bytes']>;
1082
1549
  operator_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1119,6 +1586,8 @@ export declare enum BurnedEvent_OrderBy {
1119
1586
  Name = "name",
1120
1587
  Addresses = "addresses",
1121
1588
  BlockNumber = "blockNumber",
1589
+ LogIndex = "logIndex",
1590
+ Order = "order",
1122
1591
  Operator = "operator",
1123
1592
  From = "from",
1124
1593
  Amount = "amount",
@@ -1134,6 +1603,8 @@ export declare type CfAv1LiquidationPeriodChangedEvent = Event & {
1134
1603
  /** Empty addresses array. */
1135
1604
  addresses: Array<Scalars['Bytes']>;
1136
1605
  blockNumber: Scalars['BigInt'];
1606
+ order: Scalars['BigInt'];
1607
+ logIndex: Scalars['BigInt'];
1137
1608
  host: Scalars['Bytes'];
1138
1609
  superToken: Scalars['Bytes'];
1139
1610
  isKeySet: Scalars['Boolean'];
@@ -1196,6 +1667,22 @@ export declare type CfAv1LiquidationPeriodChangedEvent_Filter = {
1196
1667
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1197
1668
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1198
1669
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1670
+ order?: Maybe<Scalars['BigInt']>;
1671
+ order_not?: Maybe<Scalars['BigInt']>;
1672
+ order_gt?: Maybe<Scalars['BigInt']>;
1673
+ order_lt?: Maybe<Scalars['BigInt']>;
1674
+ order_gte?: Maybe<Scalars['BigInt']>;
1675
+ order_lte?: Maybe<Scalars['BigInt']>;
1676
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1677
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1678
+ logIndex?: Maybe<Scalars['BigInt']>;
1679
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1680
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1681
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1682
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1683
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1684
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1685
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1199
1686
  host?: Maybe<Scalars['Bytes']>;
1200
1687
  host_not?: Maybe<Scalars['Bytes']>;
1201
1688
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1230,6 +1717,8 @@ export declare enum CfAv1LiquidationPeriodChangedEvent_OrderBy {
1230
1717
  Name = "name",
1231
1718
  Addresses = "addresses",
1232
1719
  BlockNumber = "blockNumber",
1720
+ Order = "order",
1721
+ LogIndex = "logIndex",
1233
1722
  Host = "host",
1234
1723
  SuperToken = "superToken",
1235
1724
  IsKeySet = "isKeySet",
@@ -1244,6 +1733,8 @@ export declare type ConfigChangedEvent = Event & {
1244
1733
  /** Empty addresses array. */
1245
1734
  addresses: Array<Scalars['Bytes']>;
1246
1735
  blockNumber: Scalars['BigInt'];
1736
+ logIndex: Scalars['BigInt'];
1737
+ order: Scalars['BigInt'];
1247
1738
  host: Scalars['Bytes'];
1248
1739
  superToken: Scalars['Bytes'];
1249
1740
  key: Scalars['Bytes'];
@@ -1307,6 +1798,22 @@ export declare type ConfigChangedEvent_Filter = {
1307
1798
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1308
1799
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1309
1800
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1801
+ logIndex?: Maybe<Scalars['BigInt']>;
1802
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1803
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1804
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1805
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1806
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1807
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1808
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1809
+ order?: Maybe<Scalars['BigInt']>;
1810
+ order_not?: Maybe<Scalars['BigInt']>;
1811
+ order_gt?: Maybe<Scalars['BigInt']>;
1812
+ order_lt?: Maybe<Scalars['BigInt']>;
1813
+ order_gte?: Maybe<Scalars['BigInt']>;
1814
+ order_lte?: Maybe<Scalars['BigInt']>;
1815
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1816
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1310
1817
  host?: Maybe<Scalars['Bytes']>;
1311
1818
  host_not?: Maybe<Scalars['Bytes']>;
1312
1819
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1347,6 +1854,8 @@ export declare enum ConfigChangedEvent_OrderBy {
1347
1854
  Name = "name",
1348
1855
  Addresses = "addresses",
1349
1856
  BlockNumber = "blockNumber",
1857
+ LogIndex = "logIndex",
1858
+ Order = "order",
1350
1859
  Host = "host",
1351
1860
  SuperToken = "superToken",
1352
1861
  Key = "key",
@@ -1362,6 +1871,8 @@ export declare type CustomSuperTokenCreatedEvent = Event & {
1362
1871
  /** Holds the token address. */
1363
1872
  addresses: Array<Scalars['Bytes']>;
1364
1873
  blockNumber: Scalars['BigInt'];
1874
+ logIndex: Scalars['BigInt'];
1875
+ order: Scalars['BigInt'];
1365
1876
  token: Scalars['Bytes'];
1366
1877
  };
1367
1878
  export declare type CustomSuperTokenCreatedEvent_Filter = {
@@ -1421,6 +1932,22 @@ export declare type CustomSuperTokenCreatedEvent_Filter = {
1421
1932
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1422
1933
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1423
1934
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
1935
+ logIndex?: Maybe<Scalars['BigInt']>;
1936
+ logIndex_not?: Maybe<Scalars['BigInt']>;
1937
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
1938
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
1939
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
1940
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
1941
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
1942
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
1943
+ order?: Maybe<Scalars['BigInt']>;
1944
+ order_not?: Maybe<Scalars['BigInt']>;
1945
+ order_gt?: Maybe<Scalars['BigInt']>;
1946
+ order_lt?: Maybe<Scalars['BigInt']>;
1947
+ order_gte?: Maybe<Scalars['BigInt']>;
1948
+ order_lte?: Maybe<Scalars['BigInt']>;
1949
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
1950
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1424
1951
  token?: Maybe<Scalars['Bytes']>;
1425
1952
  token_not?: Maybe<Scalars['Bytes']>;
1426
1953
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1437,6 +1964,8 @@ export declare enum CustomSuperTokenCreatedEvent_OrderBy {
1437
1964
  Name = "name",
1438
1965
  Addresses = "addresses",
1439
1966
  BlockNumber = "blockNumber",
1967
+ LogIndex = "logIndex",
1968
+ Order = "order",
1440
1969
  Token = "token"
1441
1970
  }
1442
1971
  /**
@@ -1447,6 +1976,8 @@ export declare enum CustomSuperTokenCreatedEvent_OrderBy {
1447
1976
  export declare type Event = {
1448
1977
  id: Scalars['ID'];
1449
1978
  blockNumber: Scalars['BigInt'];
1979
+ logIndex: Scalars['BigInt'];
1980
+ order: Scalars['BigInt'];
1450
1981
  name: Scalars['String'];
1451
1982
  /** Holds the addresses for accounts that were impacted by the event. */
1452
1983
  addresses: Array<Scalars['Bytes']>;
@@ -1470,6 +2001,22 @@ export declare type Event_Filter = {
1470
2001
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1471
2002
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1472
2003
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2004
+ logIndex?: Maybe<Scalars['BigInt']>;
2005
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2006
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2007
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2008
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2009
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2010
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2011
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2012
+ order?: Maybe<Scalars['BigInt']>;
2013
+ order_not?: Maybe<Scalars['BigInt']>;
2014
+ order_gt?: Maybe<Scalars['BigInt']>;
2015
+ order_lt?: Maybe<Scalars['BigInt']>;
2016
+ order_gte?: Maybe<Scalars['BigInt']>;
2017
+ order_lte?: Maybe<Scalars['BigInt']>;
2018
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2019
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1473
2020
  name?: Maybe<Scalars['String']>;
1474
2021
  name_not?: Maybe<Scalars['String']>;
1475
2022
  name_gt?: Maybe<Scalars['String']>;
@@ -1516,11 +2063,365 @@ export declare type Event_Filter = {
1516
2063
  export declare enum Event_OrderBy {
1517
2064
  Id = "id",
1518
2065
  BlockNumber = "blockNumber",
2066
+ LogIndex = "logIndex",
2067
+ Order = "order",
1519
2068
  Name = "name",
1520
2069
  Addresses = "addresses",
1521
2070
  Timestamp = "timestamp",
1522
2071
  TransactionHash = "transactionHash"
1523
2072
  }
2073
+ /** FlowOperator: A higher order entity that of a flow operator for an `AccountTokenSnapshot`. */
2074
+ export declare type FlowOperator = {
2075
+ __typename?: 'FlowOperator';
2076
+ /** ID composed of: flowOperator - token - sender */
2077
+ id: Scalars['ID'];
2078
+ createdAtTimestamp: Scalars['BigInt'];
2079
+ createdAtBlockNumber: Scalars['BigInt'];
2080
+ updatedAtTimestamp: Scalars['BigInt'];
2081
+ updatedAtBlockNumber: Scalars['BigInt'];
2082
+ /**
2083
+ * The permissions granted to the `flowOperator`.
2084
+ * Octo bitmask representation.
2085
+ */
2086
+ permissions: Scalars['Int'];
2087
+ /**
2088
+ * The flow rate allowance granted to the `flowOperator`
2089
+ * by the `sender`. This can be reset if the `sender`
2090
+ * updates the `flowOperator` flow rate allowance.
2091
+ */
2092
+ flowRateAllowanceGranted: Scalars['BigInt'];
2093
+ /**
2094
+ * The remaining flow rate allowance the `flowOperator` has,
2095
+ * this will go down every time when `flowOperator` uses it
2096
+ * (if they increase flowRate or create a new flow)
2097
+ * and can only be reset if the `sender` updates the flow
2098
+ * rate allowance.
2099
+ */
2100
+ flowRateAllowanceRemaining: Scalars['BigInt'];
2101
+ flowOperator: Scalars['Bytes'];
2102
+ sender: Account;
2103
+ token: Token;
2104
+ accountTokenSnapshot: AccountTokenSnapshot;
2105
+ flowOperatorUpdatedEvents: Array<FlowOperatorUpdatedEvent>;
2106
+ };
2107
+ /** FlowOperator: A higher order entity that of a flow operator for an `AccountTokenSnapshot`. */
2108
+ export declare type FlowOperatorFlowOperatorUpdatedEventsArgs = {
2109
+ skip?: Maybe<Scalars['Int']>;
2110
+ first?: Maybe<Scalars['Int']>;
2111
+ orderBy?: Maybe<FlowOperatorUpdatedEvent_OrderBy>;
2112
+ orderDirection?: Maybe<OrderDirection>;
2113
+ where?: Maybe<FlowOperatorUpdatedEvent_Filter>;
2114
+ };
2115
+ export declare type FlowOperatorUpdatedEvent = Event & {
2116
+ __typename?: 'FlowOperatorUpdatedEvent';
2117
+ id: Scalars['ID'];
2118
+ transactionHash: Scalars['Bytes'];
2119
+ timestamp: Scalars['BigInt'];
2120
+ name: Scalars['String'];
2121
+ /** Holds the token, sender, and flowOperator addresses. */
2122
+ addresses: Array<Scalars['Bytes']>;
2123
+ blockNumber: Scalars['BigInt'];
2124
+ logIndex: Scalars['BigInt'];
2125
+ order: Scalars['BigInt'];
2126
+ /** The address of the `token` being streamed. */
2127
+ token: Scalars['Bytes'];
2128
+ sender: Scalars['Bytes'];
2129
+ /**
2130
+ * The permissions granted to the `flowOperator`.
2131
+ * Octo bitmask representation.
2132
+ */
2133
+ permissions: Scalars['Int'];
2134
+ flowRateAllowance: Scalars['BigInt'];
2135
+ flowOperator: FlowOperator;
2136
+ };
2137
+ export declare type FlowOperatorUpdatedEvent_Filter = {
2138
+ id?: Maybe<Scalars['ID']>;
2139
+ id_not?: Maybe<Scalars['ID']>;
2140
+ id_gt?: Maybe<Scalars['ID']>;
2141
+ id_lt?: Maybe<Scalars['ID']>;
2142
+ id_gte?: Maybe<Scalars['ID']>;
2143
+ id_lte?: Maybe<Scalars['ID']>;
2144
+ id_in?: Maybe<Array<Scalars['ID']>>;
2145
+ id_not_in?: Maybe<Array<Scalars['ID']>>;
2146
+ transactionHash?: Maybe<Scalars['Bytes']>;
2147
+ transactionHash_not?: Maybe<Scalars['Bytes']>;
2148
+ transactionHash_in?: Maybe<Array<Scalars['Bytes']>>;
2149
+ transactionHash_not_in?: Maybe<Array<Scalars['Bytes']>>;
2150
+ transactionHash_contains?: Maybe<Scalars['Bytes']>;
2151
+ transactionHash_not_contains?: Maybe<Scalars['Bytes']>;
2152
+ timestamp?: Maybe<Scalars['BigInt']>;
2153
+ timestamp_not?: Maybe<Scalars['BigInt']>;
2154
+ timestamp_gt?: Maybe<Scalars['BigInt']>;
2155
+ timestamp_lt?: Maybe<Scalars['BigInt']>;
2156
+ timestamp_gte?: Maybe<Scalars['BigInt']>;
2157
+ timestamp_lte?: Maybe<Scalars['BigInt']>;
2158
+ timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
2159
+ timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
2160
+ name?: Maybe<Scalars['String']>;
2161
+ name_not?: Maybe<Scalars['String']>;
2162
+ name_gt?: Maybe<Scalars['String']>;
2163
+ name_lt?: Maybe<Scalars['String']>;
2164
+ name_gte?: Maybe<Scalars['String']>;
2165
+ name_lte?: Maybe<Scalars['String']>;
2166
+ name_in?: Maybe<Array<Scalars['String']>>;
2167
+ name_not_in?: Maybe<Array<Scalars['String']>>;
2168
+ name_contains?: Maybe<Scalars['String']>;
2169
+ name_contains_nocase?: Maybe<Scalars['String']>;
2170
+ name_not_contains?: Maybe<Scalars['String']>;
2171
+ name_not_contains_nocase?: Maybe<Scalars['String']>;
2172
+ name_starts_with?: Maybe<Scalars['String']>;
2173
+ name_starts_with_nocase?: Maybe<Scalars['String']>;
2174
+ name_not_starts_with?: Maybe<Scalars['String']>;
2175
+ name_not_starts_with_nocase?: Maybe<Scalars['String']>;
2176
+ name_ends_with?: Maybe<Scalars['String']>;
2177
+ name_ends_with_nocase?: Maybe<Scalars['String']>;
2178
+ name_not_ends_with?: Maybe<Scalars['String']>;
2179
+ name_not_ends_with_nocase?: Maybe<Scalars['String']>;
2180
+ addresses?: Maybe<Array<Scalars['Bytes']>>;
2181
+ addresses_not?: Maybe<Array<Scalars['Bytes']>>;
2182
+ addresses_contains?: Maybe<Array<Scalars['Bytes']>>;
2183
+ addresses_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
2184
+ addresses_not_contains?: Maybe<Array<Scalars['Bytes']>>;
2185
+ addresses_not_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
2186
+ blockNumber?: Maybe<Scalars['BigInt']>;
2187
+ blockNumber_not?: Maybe<Scalars['BigInt']>;
2188
+ blockNumber_gt?: Maybe<Scalars['BigInt']>;
2189
+ blockNumber_lt?: Maybe<Scalars['BigInt']>;
2190
+ blockNumber_gte?: Maybe<Scalars['BigInt']>;
2191
+ blockNumber_lte?: Maybe<Scalars['BigInt']>;
2192
+ blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2193
+ blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2194
+ logIndex?: Maybe<Scalars['BigInt']>;
2195
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2196
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2197
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2198
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2199
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2200
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2201
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2202
+ order?: Maybe<Scalars['BigInt']>;
2203
+ order_not?: Maybe<Scalars['BigInt']>;
2204
+ order_gt?: Maybe<Scalars['BigInt']>;
2205
+ order_lt?: Maybe<Scalars['BigInt']>;
2206
+ order_gte?: Maybe<Scalars['BigInt']>;
2207
+ order_lte?: Maybe<Scalars['BigInt']>;
2208
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2209
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2210
+ token?: Maybe<Scalars['Bytes']>;
2211
+ token_not?: Maybe<Scalars['Bytes']>;
2212
+ token_in?: Maybe<Array<Scalars['Bytes']>>;
2213
+ token_not_in?: Maybe<Array<Scalars['Bytes']>>;
2214
+ token_contains?: Maybe<Scalars['Bytes']>;
2215
+ token_not_contains?: Maybe<Scalars['Bytes']>;
2216
+ sender?: Maybe<Scalars['Bytes']>;
2217
+ sender_not?: Maybe<Scalars['Bytes']>;
2218
+ sender_in?: Maybe<Array<Scalars['Bytes']>>;
2219
+ sender_not_in?: Maybe<Array<Scalars['Bytes']>>;
2220
+ sender_contains?: Maybe<Scalars['Bytes']>;
2221
+ sender_not_contains?: Maybe<Scalars['Bytes']>;
2222
+ permissions?: Maybe<Scalars['Int']>;
2223
+ permissions_not?: Maybe<Scalars['Int']>;
2224
+ permissions_gt?: Maybe<Scalars['Int']>;
2225
+ permissions_lt?: Maybe<Scalars['Int']>;
2226
+ permissions_gte?: Maybe<Scalars['Int']>;
2227
+ permissions_lte?: Maybe<Scalars['Int']>;
2228
+ permissions_in?: Maybe<Array<Scalars['Int']>>;
2229
+ permissions_not_in?: Maybe<Array<Scalars['Int']>>;
2230
+ flowRateAllowance?: Maybe<Scalars['BigInt']>;
2231
+ flowRateAllowance_not?: Maybe<Scalars['BigInt']>;
2232
+ flowRateAllowance_gt?: Maybe<Scalars['BigInt']>;
2233
+ flowRateAllowance_lt?: Maybe<Scalars['BigInt']>;
2234
+ flowRateAllowance_gte?: Maybe<Scalars['BigInt']>;
2235
+ flowRateAllowance_lte?: Maybe<Scalars['BigInt']>;
2236
+ flowRateAllowance_in?: Maybe<Array<Scalars['BigInt']>>;
2237
+ flowRateAllowance_not_in?: Maybe<Array<Scalars['BigInt']>>;
2238
+ flowOperator?: Maybe<Scalars['String']>;
2239
+ flowOperator_not?: Maybe<Scalars['String']>;
2240
+ flowOperator_gt?: Maybe<Scalars['String']>;
2241
+ flowOperator_lt?: Maybe<Scalars['String']>;
2242
+ flowOperator_gte?: Maybe<Scalars['String']>;
2243
+ flowOperator_lte?: Maybe<Scalars['String']>;
2244
+ flowOperator_in?: Maybe<Array<Scalars['String']>>;
2245
+ flowOperator_not_in?: Maybe<Array<Scalars['String']>>;
2246
+ flowOperator_contains?: Maybe<Scalars['String']>;
2247
+ flowOperator_contains_nocase?: Maybe<Scalars['String']>;
2248
+ flowOperator_not_contains?: Maybe<Scalars['String']>;
2249
+ flowOperator_not_contains_nocase?: Maybe<Scalars['String']>;
2250
+ flowOperator_starts_with?: Maybe<Scalars['String']>;
2251
+ flowOperator_starts_with_nocase?: Maybe<Scalars['String']>;
2252
+ flowOperator_not_starts_with?: Maybe<Scalars['String']>;
2253
+ flowOperator_not_starts_with_nocase?: Maybe<Scalars['String']>;
2254
+ flowOperator_ends_with?: Maybe<Scalars['String']>;
2255
+ flowOperator_ends_with_nocase?: Maybe<Scalars['String']>;
2256
+ flowOperator_not_ends_with?: Maybe<Scalars['String']>;
2257
+ flowOperator_not_ends_with_nocase?: Maybe<Scalars['String']>;
2258
+ /** Filter for the block changed event. */
2259
+ _change_block?: Maybe<BlockChangedFilter>;
2260
+ };
2261
+ export declare enum FlowOperatorUpdatedEvent_OrderBy {
2262
+ Id = "id",
2263
+ TransactionHash = "transactionHash",
2264
+ Timestamp = "timestamp",
2265
+ Name = "name",
2266
+ Addresses = "addresses",
2267
+ BlockNumber = "blockNumber",
2268
+ LogIndex = "logIndex",
2269
+ Order = "order",
2270
+ Token = "token",
2271
+ Sender = "sender",
2272
+ Permissions = "permissions",
2273
+ FlowRateAllowance = "flowRateAllowance",
2274
+ FlowOperator = "flowOperator"
2275
+ }
2276
+ export declare type FlowOperator_Filter = {
2277
+ id?: Maybe<Scalars['ID']>;
2278
+ id_not?: Maybe<Scalars['ID']>;
2279
+ id_gt?: Maybe<Scalars['ID']>;
2280
+ id_lt?: Maybe<Scalars['ID']>;
2281
+ id_gte?: Maybe<Scalars['ID']>;
2282
+ id_lte?: Maybe<Scalars['ID']>;
2283
+ id_in?: Maybe<Array<Scalars['ID']>>;
2284
+ id_not_in?: Maybe<Array<Scalars['ID']>>;
2285
+ createdAtTimestamp?: Maybe<Scalars['BigInt']>;
2286
+ createdAtTimestamp_not?: Maybe<Scalars['BigInt']>;
2287
+ createdAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
2288
+ createdAtTimestamp_lt?: Maybe<Scalars['BigInt']>;
2289
+ createdAtTimestamp_gte?: Maybe<Scalars['BigInt']>;
2290
+ createdAtTimestamp_lte?: Maybe<Scalars['BigInt']>;
2291
+ createdAtTimestamp_in?: Maybe<Array<Scalars['BigInt']>>;
2292
+ createdAtTimestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
2293
+ createdAtBlockNumber?: Maybe<Scalars['BigInt']>;
2294
+ createdAtBlockNumber_not?: Maybe<Scalars['BigInt']>;
2295
+ createdAtBlockNumber_gt?: Maybe<Scalars['BigInt']>;
2296
+ createdAtBlockNumber_lt?: Maybe<Scalars['BigInt']>;
2297
+ createdAtBlockNumber_gte?: Maybe<Scalars['BigInt']>;
2298
+ createdAtBlockNumber_lte?: Maybe<Scalars['BigInt']>;
2299
+ createdAtBlockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2300
+ createdAtBlockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2301
+ updatedAtTimestamp?: Maybe<Scalars['BigInt']>;
2302
+ updatedAtTimestamp_not?: Maybe<Scalars['BigInt']>;
2303
+ updatedAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
2304
+ updatedAtTimestamp_lt?: Maybe<Scalars['BigInt']>;
2305
+ updatedAtTimestamp_gte?: Maybe<Scalars['BigInt']>;
2306
+ updatedAtTimestamp_lte?: Maybe<Scalars['BigInt']>;
2307
+ updatedAtTimestamp_in?: Maybe<Array<Scalars['BigInt']>>;
2308
+ updatedAtTimestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
2309
+ updatedAtBlockNumber?: Maybe<Scalars['BigInt']>;
2310
+ updatedAtBlockNumber_not?: Maybe<Scalars['BigInt']>;
2311
+ updatedAtBlockNumber_gt?: Maybe<Scalars['BigInt']>;
2312
+ updatedAtBlockNumber_lt?: Maybe<Scalars['BigInt']>;
2313
+ updatedAtBlockNumber_gte?: Maybe<Scalars['BigInt']>;
2314
+ updatedAtBlockNumber_lte?: Maybe<Scalars['BigInt']>;
2315
+ updatedAtBlockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2316
+ updatedAtBlockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2317
+ permissions?: Maybe<Scalars['Int']>;
2318
+ permissions_not?: Maybe<Scalars['Int']>;
2319
+ permissions_gt?: Maybe<Scalars['Int']>;
2320
+ permissions_lt?: Maybe<Scalars['Int']>;
2321
+ permissions_gte?: Maybe<Scalars['Int']>;
2322
+ permissions_lte?: Maybe<Scalars['Int']>;
2323
+ permissions_in?: Maybe<Array<Scalars['Int']>>;
2324
+ permissions_not_in?: Maybe<Array<Scalars['Int']>>;
2325
+ flowRateAllowanceGranted?: Maybe<Scalars['BigInt']>;
2326
+ flowRateAllowanceGranted_not?: Maybe<Scalars['BigInt']>;
2327
+ flowRateAllowanceGranted_gt?: Maybe<Scalars['BigInt']>;
2328
+ flowRateAllowanceGranted_lt?: Maybe<Scalars['BigInt']>;
2329
+ flowRateAllowanceGranted_gte?: Maybe<Scalars['BigInt']>;
2330
+ flowRateAllowanceGranted_lte?: Maybe<Scalars['BigInt']>;
2331
+ flowRateAllowanceGranted_in?: Maybe<Array<Scalars['BigInt']>>;
2332
+ flowRateAllowanceGranted_not_in?: Maybe<Array<Scalars['BigInt']>>;
2333
+ flowRateAllowanceRemaining?: Maybe<Scalars['BigInt']>;
2334
+ flowRateAllowanceRemaining_not?: Maybe<Scalars['BigInt']>;
2335
+ flowRateAllowanceRemaining_gt?: Maybe<Scalars['BigInt']>;
2336
+ flowRateAllowanceRemaining_lt?: Maybe<Scalars['BigInt']>;
2337
+ flowRateAllowanceRemaining_gte?: Maybe<Scalars['BigInt']>;
2338
+ flowRateAllowanceRemaining_lte?: Maybe<Scalars['BigInt']>;
2339
+ flowRateAllowanceRemaining_in?: Maybe<Array<Scalars['BigInt']>>;
2340
+ flowRateAllowanceRemaining_not_in?: Maybe<Array<Scalars['BigInt']>>;
2341
+ flowOperator?: Maybe<Scalars['Bytes']>;
2342
+ flowOperator_not?: Maybe<Scalars['Bytes']>;
2343
+ flowOperator_in?: Maybe<Array<Scalars['Bytes']>>;
2344
+ flowOperator_not_in?: Maybe<Array<Scalars['Bytes']>>;
2345
+ flowOperator_contains?: Maybe<Scalars['Bytes']>;
2346
+ flowOperator_not_contains?: Maybe<Scalars['Bytes']>;
2347
+ sender?: Maybe<Scalars['String']>;
2348
+ sender_not?: Maybe<Scalars['String']>;
2349
+ sender_gt?: Maybe<Scalars['String']>;
2350
+ sender_lt?: Maybe<Scalars['String']>;
2351
+ sender_gte?: Maybe<Scalars['String']>;
2352
+ sender_lte?: Maybe<Scalars['String']>;
2353
+ sender_in?: Maybe<Array<Scalars['String']>>;
2354
+ sender_not_in?: Maybe<Array<Scalars['String']>>;
2355
+ sender_contains?: Maybe<Scalars['String']>;
2356
+ sender_contains_nocase?: Maybe<Scalars['String']>;
2357
+ sender_not_contains?: Maybe<Scalars['String']>;
2358
+ sender_not_contains_nocase?: Maybe<Scalars['String']>;
2359
+ sender_starts_with?: Maybe<Scalars['String']>;
2360
+ sender_starts_with_nocase?: Maybe<Scalars['String']>;
2361
+ sender_not_starts_with?: Maybe<Scalars['String']>;
2362
+ sender_not_starts_with_nocase?: Maybe<Scalars['String']>;
2363
+ sender_ends_with?: Maybe<Scalars['String']>;
2364
+ sender_ends_with_nocase?: Maybe<Scalars['String']>;
2365
+ sender_not_ends_with?: Maybe<Scalars['String']>;
2366
+ sender_not_ends_with_nocase?: Maybe<Scalars['String']>;
2367
+ token?: Maybe<Scalars['String']>;
2368
+ token_not?: Maybe<Scalars['String']>;
2369
+ token_gt?: Maybe<Scalars['String']>;
2370
+ token_lt?: Maybe<Scalars['String']>;
2371
+ token_gte?: Maybe<Scalars['String']>;
2372
+ token_lte?: Maybe<Scalars['String']>;
2373
+ token_in?: Maybe<Array<Scalars['String']>>;
2374
+ token_not_in?: Maybe<Array<Scalars['String']>>;
2375
+ token_contains?: Maybe<Scalars['String']>;
2376
+ token_contains_nocase?: Maybe<Scalars['String']>;
2377
+ token_not_contains?: Maybe<Scalars['String']>;
2378
+ token_not_contains_nocase?: Maybe<Scalars['String']>;
2379
+ token_starts_with?: Maybe<Scalars['String']>;
2380
+ token_starts_with_nocase?: Maybe<Scalars['String']>;
2381
+ token_not_starts_with?: Maybe<Scalars['String']>;
2382
+ token_not_starts_with_nocase?: Maybe<Scalars['String']>;
2383
+ token_ends_with?: Maybe<Scalars['String']>;
2384
+ token_ends_with_nocase?: Maybe<Scalars['String']>;
2385
+ token_not_ends_with?: Maybe<Scalars['String']>;
2386
+ token_not_ends_with_nocase?: Maybe<Scalars['String']>;
2387
+ accountTokenSnapshot?: Maybe<Scalars['String']>;
2388
+ accountTokenSnapshot_not?: Maybe<Scalars['String']>;
2389
+ accountTokenSnapshot_gt?: Maybe<Scalars['String']>;
2390
+ accountTokenSnapshot_lt?: Maybe<Scalars['String']>;
2391
+ accountTokenSnapshot_gte?: Maybe<Scalars['String']>;
2392
+ accountTokenSnapshot_lte?: Maybe<Scalars['String']>;
2393
+ accountTokenSnapshot_in?: Maybe<Array<Scalars['String']>>;
2394
+ accountTokenSnapshot_not_in?: Maybe<Array<Scalars['String']>>;
2395
+ accountTokenSnapshot_contains?: Maybe<Scalars['String']>;
2396
+ accountTokenSnapshot_contains_nocase?: Maybe<Scalars['String']>;
2397
+ accountTokenSnapshot_not_contains?: Maybe<Scalars['String']>;
2398
+ accountTokenSnapshot_not_contains_nocase?: Maybe<Scalars['String']>;
2399
+ accountTokenSnapshot_starts_with?: Maybe<Scalars['String']>;
2400
+ accountTokenSnapshot_starts_with_nocase?: Maybe<Scalars['String']>;
2401
+ accountTokenSnapshot_not_starts_with?: Maybe<Scalars['String']>;
2402
+ accountTokenSnapshot_not_starts_with_nocase?: Maybe<Scalars['String']>;
2403
+ accountTokenSnapshot_ends_with?: Maybe<Scalars['String']>;
2404
+ accountTokenSnapshot_ends_with_nocase?: Maybe<Scalars['String']>;
2405
+ accountTokenSnapshot_not_ends_with?: Maybe<Scalars['String']>;
2406
+ accountTokenSnapshot_not_ends_with_nocase?: Maybe<Scalars['String']>;
2407
+ /** Filter for the block changed event. */
2408
+ _change_block?: Maybe<BlockChangedFilter>;
2409
+ };
2410
+ export declare enum FlowOperator_OrderBy {
2411
+ Id = "id",
2412
+ CreatedAtTimestamp = "createdAtTimestamp",
2413
+ CreatedAtBlockNumber = "createdAtBlockNumber",
2414
+ UpdatedAtTimestamp = "updatedAtTimestamp",
2415
+ UpdatedAtBlockNumber = "updatedAtBlockNumber",
2416
+ Permissions = "permissions",
2417
+ FlowRateAllowanceGranted = "flowRateAllowanceGranted",
2418
+ FlowRateAllowanceRemaining = "flowRateAllowanceRemaining",
2419
+ FlowOperator = "flowOperator",
2420
+ Sender = "sender",
2421
+ Token = "token",
2422
+ AccountTokenSnapshot = "accountTokenSnapshot",
2423
+ FlowOperatorUpdatedEvents = "flowOperatorUpdatedEvents"
2424
+ }
1524
2425
  /**
1525
2426
  * FlowUpdated: An `Event` entity that is emitted
1526
2427
  * when a flow is created, updated, or deleted.
@@ -1534,14 +2435,23 @@ export declare type FlowUpdatedEvent = Event & {
1534
2435
  /** Holds the token, sender and receiver addresses. */
1535
2436
  addresses: Array<Scalars['Bytes']>;
1536
2437
  blockNumber: Scalars['BigInt'];
2438
+ logIndex: Scalars['BigInt'];
2439
+ order: Scalars['BigInt'];
1537
2440
  /** The address of the `token` being streamed. */
1538
2441
  token: Scalars['Bytes'];
1539
2442
  sender: Scalars['Bytes'];
1540
2443
  receiver: Scalars['Bytes'];
2444
+ /**
2445
+ * The address that is triggering the flow update.
2446
+ * This will be the zero address until the flowOperator
2447
+ * feature is live.
2448
+ */
2449
+ flowOperator: Scalars['Bytes'];
1541
2450
  /** The flow rate per second. */
1542
2451
  flowRate: Scalars['BigInt'];
1543
2452
  totalSenderFlowRate: Scalars['BigInt'];
1544
2453
  totalReceiverFlowRate: Scalars['BigInt'];
2454
+ deposit: Scalars['BigInt'];
1545
2455
  userData: Scalars['Bytes'];
1546
2456
  /** The previous flow rate. */
1547
2457
  oldFlowRate: Scalars['BigInt'];
@@ -1617,6 +2527,22 @@ export declare type FlowUpdatedEvent_Filter = {
1617
2527
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1618
2528
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1619
2529
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2530
+ logIndex?: Maybe<Scalars['BigInt']>;
2531
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2532
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2533
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2534
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2535
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2536
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2537
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2538
+ order?: Maybe<Scalars['BigInt']>;
2539
+ order_not?: Maybe<Scalars['BigInt']>;
2540
+ order_gt?: Maybe<Scalars['BigInt']>;
2541
+ order_lt?: Maybe<Scalars['BigInt']>;
2542
+ order_gte?: Maybe<Scalars['BigInt']>;
2543
+ order_lte?: Maybe<Scalars['BigInt']>;
2544
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2545
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1620
2546
  token?: Maybe<Scalars['Bytes']>;
1621
2547
  token_not?: Maybe<Scalars['Bytes']>;
1622
2548
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1635,6 +2561,12 @@ export declare type FlowUpdatedEvent_Filter = {
1635
2561
  receiver_not_in?: Maybe<Array<Scalars['Bytes']>>;
1636
2562
  receiver_contains?: Maybe<Scalars['Bytes']>;
1637
2563
  receiver_not_contains?: Maybe<Scalars['Bytes']>;
2564
+ flowOperator?: Maybe<Scalars['Bytes']>;
2565
+ flowOperator_not?: Maybe<Scalars['Bytes']>;
2566
+ flowOperator_in?: Maybe<Array<Scalars['Bytes']>>;
2567
+ flowOperator_not_in?: Maybe<Array<Scalars['Bytes']>>;
2568
+ flowOperator_contains?: Maybe<Scalars['Bytes']>;
2569
+ flowOperator_not_contains?: Maybe<Scalars['Bytes']>;
1638
2570
  flowRate?: Maybe<Scalars['BigInt']>;
1639
2571
  flowRate_not?: Maybe<Scalars['BigInt']>;
1640
2572
  flowRate_gt?: Maybe<Scalars['BigInt']>;
@@ -1659,6 +2591,14 @@ export declare type FlowUpdatedEvent_Filter = {
1659
2591
  totalReceiverFlowRate_lte?: Maybe<Scalars['BigInt']>;
1660
2592
  totalReceiverFlowRate_in?: Maybe<Array<Scalars['BigInt']>>;
1661
2593
  totalReceiverFlowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
2594
+ deposit?: Maybe<Scalars['BigInt']>;
2595
+ deposit_not?: Maybe<Scalars['BigInt']>;
2596
+ deposit_gt?: Maybe<Scalars['BigInt']>;
2597
+ deposit_lt?: Maybe<Scalars['BigInt']>;
2598
+ deposit_gte?: Maybe<Scalars['BigInt']>;
2599
+ deposit_lte?: Maybe<Scalars['BigInt']>;
2600
+ deposit_in?: Maybe<Array<Scalars['BigInt']>>;
2601
+ deposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
1662
2602
  userData?: Maybe<Scalars['Bytes']>;
1663
2603
  userData_not?: Maybe<Scalars['Bytes']>;
1664
2604
  userData_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1719,12 +2659,16 @@ export declare enum FlowUpdatedEvent_OrderBy {
1719
2659
  Name = "name",
1720
2660
  Addresses = "addresses",
1721
2661
  BlockNumber = "blockNumber",
2662
+ LogIndex = "logIndex",
2663
+ Order = "order",
1722
2664
  Token = "token",
1723
2665
  Sender = "sender",
1724
2666
  Receiver = "receiver",
2667
+ FlowOperator = "flowOperator",
1725
2668
  FlowRate = "flowRate",
1726
2669
  TotalSenderFlowRate = "totalSenderFlowRate",
1727
2670
  TotalReceiverFlowRate = "totalReceiverFlowRate",
2671
+ Deposit = "deposit",
1728
2672
  UserData = "userData",
1729
2673
  OldFlowRate = "oldFlowRate",
1730
2674
  Type = "type",
@@ -1739,6 +2683,8 @@ export declare type GovernanceReplacedEvent = Event & {
1739
2683
  name: Scalars['String'];
1740
2684
  addresses: Array<Scalars['Bytes']>;
1741
2685
  blockNumber: Scalars['BigInt'];
2686
+ logIndex: Scalars['BigInt'];
2687
+ order: Scalars['BigInt'];
1742
2688
  /** Empty addresses array. */
1743
2689
  oldGovernance: Scalars['Bytes'];
1744
2690
  newGovernance: Scalars['Bytes'];
@@ -1800,6 +2746,22 @@ export declare type GovernanceReplacedEvent_Filter = {
1800
2746
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1801
2747
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1802
2748
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2749
+ logIndex?: Maybe<Scalars['BigInt']>;
2750
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2751
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2752
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2753
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2754
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2755
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2756
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2757
+ order?: Maybe<Scalars['BigInt']>;
2758
+ order_not?: Maybe<Scalars['BigInt']>;
2759
+ order_gt?: Maybe<Scalars['BigInt']>;
2760
+ order_lt?: Maybe<Scalars['BigInt']>;
2761
+ order_gte?: Maybe<Scalars['BigInt']>;
2762
+ order_lte?: Maybe<Scalars['BigInt']>;
2763
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2764
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1803
2765
  oldGovernance?: Maybe<Scalars['Bytes']>;
1804
2766
  oldGovernance_not?: Maybe<Scalars['Bytes']>;
1805
2767
  oldGovernance_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1822,10 +2784,12 @@ export declare enum GovernanceReplacedEvent_OrderBy {
1822
2784
  Name = "name",
1823
2785
  Addresses = "addresses",
1824
2786
  BlockNumber = "blockNumber",
2787
+ LogIndex = "logIndex",
2788
+ Order = "order",
1825
2789
  OldGovernance = "oldGovernance",
1826
2790
  NewGovernance = "newGovernance"
1827
2791
  }
1828
- /** Index: A Index HOL entity. */
2792
+ /** Index: An Index higher order entity. */
1829
2793
  export declare type Index = {
1830
2794
  __typename?: 'Index';
1831
2795
  /** ID composed of: publisherAddress-tokenAddress-indexId */
@@ -1870,7 +2834,7 @@ export declare type Index = {
1870
2834
  indexUnitsUpdatedEvents: Array<IndexUnitsUpdatedEvent>;
1871
2835
  indexUnsubscribedEvents: Array<IndexUnsubscribedEvent>;
1872
2836
  };
1873
- /** Index: A Index HOL entity. */
2837
+ /** Index: An Index higher order entity. */
1874
2838
  export declare type IndexSubscriptionsArgs = {
1875
2839
  skip?: Maybe<Scalars['Int']>;
1876
2840
  first?: Maybe<Scalars['Int']>;
@@ -1878,7 +2842,7 @@ export declare type IndexSubscriptionsArgs = {
1878
2842
  orderDirection?: Maybe<OrderDirection>;
1879
2843
  where?: Maybe<IndexSubscription_Filter>;
1880
2844
  };
1881
- /** Index: A Index HOL entity. */
2845
+ /** Index: An Index higher order entity. */
1882
2846
  export declare type IndexIndexDistributionClaimedEventsArgs = {
1883
2847
  skip?: Maybe<Scalars['Int']>;
1884
2848
  first?: Maybe<Scalars['Int']>;
@@ -1886,7 +2850,7 @@ export declare type IndexIndexDistributionClaimedEventsArgs = {
1886
2850
  orderDirection?: Maybe<OrderDirection>;
1887
2851
  where?: Maybe<IndexDistributionClaimedEvent_Filter>;
1888
2852
  };
1889
- /** Index: A Index HOL entity. */
2853
+ /** Index: An Index higher order entity. */
1890
2854
  export declare type IndexIndexUpdatedEventsArgs = {
1891
2855
  skip?: Maybe<Scalars['Int']>;
1892
2856
  first?: Maybe<Scalars['Int']>;
@@ -1894,7 +2858,7 @@ export declare type IndexIndexUpdatedEventsArgs = {
1894
2858
  orderDirection?: Maybe<OrderDirection>;
1895
2859
  where?: Maybe<IndexUpdatedEvent_Filter>;
1896
2860
  };
1897
- /** Index: A Index HOL entity. */
2861
+ /** Index: An Index higher order entity. */
1898
2862
  export declare type IndexIndexSubscribedEventsArgs = {
1899
2863
  skip?: Maybe<Scalars['Int']>;
1900
2864
  first?: Maybe<Scalars['Int']>;
@@ -1902,7 +2866,7 @@ export declare type IndexIndexSubscribedEventsArgs = {
1902
2866
  orderDirection?: Maybe<OrderDirection>;
1903
2867
  where?: Maybe<IndexSubscribedEvent_Filter>;
1904
2868
  };
1905
- /** Index: A Index HOL entity. */
2869
+ /** Index: An Index higher order entity. */
1906
2870
  export declare type IndexIndexUnitsUpdatedEventsArgs = {
1907
2871
  skip?: Maybe<Scalars['Int']>;
1908
2872
  first?: Maybe<Scalars['Int']>;
@@ -1910,7 +2874,7 @@ export declare type IndexIndexUnitsUpdatedEventsArgs = {
1910
2874
  orderDirection?: Maybe<OrderDirection>;
1911
2875
  where?: Maybe<IndexUnitsUpdatedEvent_Filter>;
1912
2876
  };
1913
- /** Index: A Index HOL entity. */
2877
+ /** Index: An Index higher order entity. */
1914
2878
  export declare type IndexIndexUnsubscribedEventsArgs = {
1915
2879
  skip?: Maybe<Scalars['Int']>;
1916
2880
  first?: Maybe<Scalars['Int']>;
@@ -1927,6 +2891,8 @@ export declare type IndexCreatedEvent = Event & {
1927
2891
  /** Holds the token and publisher addresses. */
1928
2892
  addresses: Array<Scalars['Bytes']>;
1929
2893
  blockNumber: Scalars['BigInt'];
2894
+ logIndex: Scalars['BigInt'];
2895
+ order: Scalars['BigInt'];
1930
2896
  token: Scalars['Bytes'];
1931
2897
  publisher: Scalars['Bytes'];
1932
2898
  indexId: Scalars['BigInt'];
@@ -1990,6 +2956,22 @@ export declare type IndexCreatedEvent_Filter = {
1990
2956
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1991
2957
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1992
2958
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2959
+ logIndex?: Maybe<Scalars['BigInt']>;
2960
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2961
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2962
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2963
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2964
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2965
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2966
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2967
+ order?: Maybe<Scalars['BigInt']>;
2968
+ order_not?: Maybe<Scalars['BigInt']>;
2969
+ order_gt?: Maybe<Scalars['BigInt']>;
2970
+ order_lt?: Maybe<Scalars['BigInt']>;
2971
+ order_gte?: Maybe<Scalars['BigInt']>;
2972
+ order_lte?: Maybe<Scalars['BigInt']>;
2973
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2974
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
1993
2975
  token?: Maybe<Scalars['Bytes']>;
1994
2976
  token_not?: Maybe<Scalars['Bytes']>;
1995
2977
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2046,6 +3028,8 @@ export declare enum IndexCreatedEvent_OrderBy {
2046
3028
  Name = "name",
2047
3029
  Addresses = "addresses",
2048
3030
  BlockNumber = "blockNumber",
3031
+ LogIndex = "logIndex",
3032
+ Order = "order",
2049
3033
  Token = "token",
2050
3034
  Publisher = "publisher",
2051
3035
  IndexId = "indexId",
@@ -2061,6 +3045,8 @@ export declare type IndexDistributionClaimedEvent = Event & {
2061
3045
  /** Holds the token, publisher and subscriber addresses. */
2062
3046
  addresses: Array<Scalars['Bytes']>;
2063
3047
  blockNumber: Scalars['BigInt'];
3048
+ logIndex: Scalars['BigInt'];
3049
+ order: Scalars['BigInt'];
2064
3050
  token: Scalars['Bytes'];
2065
3051
  publisher: Scalars['Bytes'];
2066
3052
  indexId: Scalars['BigInt'];
@@ -2125,6 +3111,22 @@ export declare type IndexDistributionClaimedEvent_Filter = {
2125
3111
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2126
3112
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2127
3113
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
3114
+ logIndex?: Maybe<Scalars['BigInt']>;
3115
+ logIndex_not?: Maybe<Scalars['BigInt']>;
3116
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
3117
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
3118
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
3119
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
3120
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
3121
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
3122
+ order?: Maybe<Scalars['BigInt']>;
3123
+ order_not?: Maybe<Scalars['BigInt']>;
3124
+ order_gt?: Maybe<Scalars['BigInt']>;
3125
+ order_lt?: Maybe<Scalars['BigInt']>;
3126
+ order_gte?: Maybe<Scalars['BigInt']>;
3127
+ order_lte?: Maybe<Scalars['BigInt']>;
3128
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
3129
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2128
3130
  token?: Maybe<Scalars['Bytes']>;
2129
3131
  token_not?: Maybe<Scalars['Bytes']>;
2130
3132
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2189,6 +3191,8 @@ export declare enum IndexDistributionClaimedEvent_OrderBy {
2189
3191
  Name = "name",
2190
3192
  Addresses = "addresses",
2191
3193
  BlockNumber = "blockNumber",
3194
+ LogIndex = "logIndex",
3195
+ Order = "order",
2192
3196
  Token = "token",
2193
3197
  Publisher = "publisher",
2194
3198
  IndexId = "indexId",
@@ -2205,6 +3209,8 @@ export declare type IndexSubscribedEvent = Event & {
2205
3209
  /** Holds the token, publisher and subscriber addresses. */
2206
3210
  addresses: Array<Scalars['Bytes']>;
2207
3211
  blockNumber: Scalars['BigInt'];
3212
+ logIndex: Scalars['BigInt'];
3213
+ order: Scalars['BigInt'];
2208
3214
  token: Scalars['Bytes'];
2209
3215
  publisher: Scalars['Bytes'];
2210
3216
  indexId: Scalars['BigInt'];
@@ -2269,6 +3275,22 @@ export declare type IndexSubscribedEvent_Filter = {
2269
3275
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2270
3276
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2271
3277
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
3278
+ logIndex?: Maybe<Scalars['BigInt']>;
3279
+ logIndex_not?: Maybe<Scalars['BigInt']>;
3280
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
3281
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
3282
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
3283
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
3284
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
3285
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
3286
+ order?: Maybe<Scalars['BigInt']>;
3287
+ order_not?: Maybe<Scalars['BigInt']>;
3288
+ order_gt?: Maybe<Scalars['BigInt']>;
3289
+ order_lt?: Maybe<Scalars['BigInt']>;
3290
+ order_gte?: Maybe<Scalars['BigInt']>;
3291
+ order_lte?: Maybe<Scalars['BigInt']>;
3292
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
3293
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2272
3294
  token?: Maybe<Scalars['Bytes']>;
2273
3295
  token_not?: Maybe<Scalars['Bytes']>;
2274
3296
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2331,6 +3353,8 @@ export declare enum IndexSubscribedEvent_OrderBy {
2331
3353
  Name = "name",
2332
3354
  Addresses = "addresses",
2333
3355
  BlockNumber = "blockNumber",
3356
+ LogIndex = "logIndex",
3357
+ Order = "order",
2334
3358
  Token = "token",
2335
3359
  Publisher = "publisher",
2336
3360
  IndexId = "indexId",
@@ -2339,7 +3363,7 @@ export declare enum IndexSubscribedEvent_OrderBy {
2339
3363
  Index = "index"
2340
3364
  }
2341
3365
  /**
2342
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
3366
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
2343
3367
  * `Index`.
2344
3368
  */
2345
3369
  export declare type IndexSubscription = {
@@ -2380,7 +3404,7 @@ export declare type IndexSubscription = {
2380
3404
  subscriptionUnitsUpdatedEvents: Array<SubscriptionUnitsUpdatedEvent>;
2381
3405
  };
2382
3406
  /**
2383
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
3407
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
2384
3408
  * `Index`.
2385
3409
  */
2386
3410
  export declare type IndexSubscriptionSubscriptionApprovedEventsArgs = {
@@ -2391,7 +3415,7 @@ export declare type IndexSubscriptionSubscriptionApprovedEventsArgs = {
2391
3415
  where?: Maybe<SubscriptionApprovedEvent_Filter>;
2392
3416
  };
2393
3417
  /**
2394
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
3418
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
2395
3419
  * `Index`.
2396
3420
  */
2397
3421
  export declare type IndexSubscriptionSubscriptionDistributionClaimedEventsArgs = {
@@ -2402,7 +3426,7 @@ export declare type IndexSubscriptionSubscriptionDistributionClaimedEventsArgs =
2402
3426
  where?: Maybe<SubscriptionDistributionClaimedEvent_Filter>;
2403
3427
  };
2404
3428
  /**
2405
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
3429
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
2406
3430
  * `Index`.
2407
3431
  */
2408
3432
  export declare type IndexSubscriptionSubscriptionRevokedEventsArgs = {
@@ -2413,7 +3437,7 @@ export declare type IndexSubscriptionSubscriptionRevokedEventsArgs = {
2413
3437
  where?: Maybe<SubscriptionRevokedEvent_Filter>;
2414
3438
  };
2415
3439
  /**
2416
- * IndexSubscription: A HOL entity that contains subscription data for a `subscriber` account of a particular
3440
+ * IndexSubscription: A higher order entity that contains subscription data for a `subscriber` account of a particular
2417
3441
  * `Index`.
2418
3442
  */
2419
3443
  export declare type IndexSubscriptionSubscriptionUnitsUpdatedEventsArgs = {
@@ -2561,6 +3585,8 @@ export declare type IndexUnitsUpdatedEvent = Event & {
2561
3585
  /** Holds the token, publisher and subscriber addresses. */
2562
3586
  addresses: Array<Scalars['Bytes']>;
2563
3587
  blockNumber: Scalars['BigInt'];
3588
+ logIndex: Scalars['BigInt'];
3589
+ order: Scalars['BigInt'];
2564
3590
  token: Scalars['Bytes'];
2565
3591
  publisher: Scalars['Bytes'];
2566
3592
  indexId: Scalars['BigInt'];
@@ -2627,6 +3653,22 @@ export declare type IndexUnitsUpdatedEvent_Filter = {
2627
3653
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2628
3654
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2629
3655
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
3656
+ logIndex?: Maybe<Scalars['BigInt']>;
3657
+ logIndex_not?: Maybe<Scalars['BigInt']>;
3658
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
3659
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
3660
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
3661
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
3662
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
3663
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
3664
+ order?: Maybe<Scalars['BigInt']>;
3665
+ order_not?: Maybe<Scalars['BigInt']>;
3666
+ order_gt?: Maybe<Scalars['BigInt']>;
3667
+ order_lt?: Maybe<Scalars['BigInt']>;
3668
+ order_gte?: Maybe<Scalars['BigInt']>;
3669
+ order_lte?: Maybe<Scalars['BigInt']>;
3670
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
3671
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2630
3672
  token?: Maybe<Scalars['Bytes']>;
2631
3673
  token_not?: Maybe<Scalars['Bytes']>;
2632
3674
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2705,6 +3747,8 @@ export declare enum IndexUnitsUpdatedEvent_OrderBy {
2705
3747
  Name = "name",
2706
3748
  Addresses = "addresses",
2707
3749
  BlockNumber = "blockNumber",
3750
+ LogIndex = "logIndex",
3751
+ Order = "order",
2708
3752
  Token = "token",
2709
3753
  Publisher = "publisher",
2710
3754
  IndexId = "indexId",
@@ -2723,6 +3767,8 @@ export declare type IndexUnsubscribedEvent = Event & {
2723
3767
  /** Holds the token, publisher and subscriber addresses. */
2724
3768
  addresses: Array<Scalars['Bytes']>;
2725
3769
  blockNumber: Scalars['BigInt'];
3770
+ logIndex: Scalars['BigInt'];
3771
+ order: Scalars['BigInt'];
2726
3772
  token: Scalars['Bytes'];
2727
3773
  publisher: Scalars['Bytes'];
2728
3774
  indexId: Scalars['BigInt'];
@@ -2787,6 +3833,22 @@ export declare type IndexUnsubscribedEvent_Filter = {
2787
3833
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2788
3834
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2789
3835
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
3836
+ logIndex?: Maybe<Scalars['BigInt']>;
3837
+ logIndex_not?: Maybe<Scalars['BigInt']>;
3838
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
3839
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
3840
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
3841
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
3842
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
3843
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
3844
+ order?: Maybe<Scalars['BigInt']>;
3845
+ order_not?: Maybe<Scalars['BigInt']>;
3846
+ order_gt?: Maybe<Scalars['BigInt']>;
3847
+ order_lt?: Maybe<Scalars['BigInt']>;
3848
+ order_gte?: Maybe<Scalars['BigInt']>;
3849
+ order_lte?: Maybe<Scalars['BigInt']>;
3850
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
3851
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2790
3852
  token?: Maybe<Scalars['Bytes']>;
2791
3853
  token_not?: Maybe<Scalars['Bytes']>;
2792
3854
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2849,6 +3911,8 @@ export declare enum IndexUnsubscribedEvent_OrderBy {
2849
3911
  Name = "name",
2850
3912
  Addresses = "addresses",
2851
3913
  BlockNumber = "blockNumber",
3914
+ LogIndex = "logIndex",
3915
+ Order = "order",
2852
3916
  Token = "token",
2853
3917
  Publisher = "publisher",
2854
3918
  IndexId = "indexId",
@@ -2865,6 +3929,8 @@ export declare type IndexUpdatedEvent = Event & {
2865
3929
  /** Holds the token and publisher addresses. */
2866
3930
  addresses: Array<Scalars['Bytes']>;
2867
3931
  blockNumber: Scalars['BigInt'];
3932
+ logIndex: Scalars['BigInt'];
3933
+ order: Scalars['BigInt'];
2868
3934
  token: Scalars['Bytes'];
2869
3935
  publisher: Scalars['Bytes'];
2870
3936
  indexId: Scalars['BigInt'];
@@ -2932,6 +3998,22 @@ export declare type IndexUpdatedEvent_Filter = {
2932
3998
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2933
3999
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2934
4000
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
4001
+ logIndex?: Maybe<Scalars['BigInt']>;
4002
+ logIndex_not?: Maybe<Scalars['BigInt']>;
4003
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
4004
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
4005
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
4006
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
4007
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
4008
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
4009
+ order?: Maybe<Scalars['BigInt']>;
4010
+ order_not?: Maybe<Scalars['BigInt']>;
4011
+ order_gt?: Maybe<Scalars['BigInt']>;
4012
+ order_lt?: Maybe<Scalars['BigInt']>;
4013
+ order_gte?: Maybe<Scalars['BigInt']>;
4014
+ order_lte?: Maybe<Scalars['BigInt']>;
4015
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
4016
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2935
4017
  token?: Maybe<Scalars['Bytes']>;
2936
4018
  token_not?: Maybe<Scalars['Bytes']>;
2937
4019
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3020,6 +4102,8 @@ export declare enum IndexUpdatedEvent_OrderBy {
3020
4102
  Name = "name",
3021
4103
  Addresses = "addresses",
3022
4104
  BlockNumber = "blockNumber",
4105
+ LogIndex = "logIndex",
4106
+ Order = "order",
3023
4107
  Token = "token",
3024
4108
  Publisher = "publisher",
3025
4109
  IndexId = "indexId",
@@ -3222,6 +4306,8 @@ export declare type JailEvent = Event & {
3222
4306
  /** Empty addresses array. */
3223
4307
  addresses: Array<Scalars['Bytes']>;
3224
4308
  blockNumber: Scalars['BigInt'];
4309
+ logIndex: Scalars['BigInt'];
4310
+ order: Scalars['BigInt'];
3225
4311
  app: Scalars['Bytes'];
3226
4312
  reason: Scalars['BigInt'];
3227
4313
  };
@@ -3282,6 +4368,22 @@ export declare type JailEvent_Filter = {
3282
4368
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3283
4369
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3284
4370
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
4371
+ logIndex?: Maybe<Scalars['BigInt']>;
4372
+ logIndex_not?: Maybe<Scalars['BigInt']>;
4373
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
4374
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
4375
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
4376
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
4377
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
4378
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
4379
+ order?: Maybe<Scalars['BigInt']>;
4380
+ order_not?: Maybe<Scalars['BigInt']>;
4381
+ order_gt?: Maybe<Scalars['BigInt']>;
4382
+ order_lt?: Maybe<Scalars['BigInt']>;
4383
+ order_gte?: Maybe<Scalars['BigInt']>;
4384
+ order_lte?: Maybe<Scalars['BigInt']>;
4385
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
4386
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
3285
4387
  app?: Maybe<Scalars['Bytes']>;
3286
4388
  app_not?: Maybe<Scalars['Bytes']>;
3287
4389
  app_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3306,6 +4408,8 @@ export declare enum JailEvent_OrderBy {
3306
4408
  Name = "name",
3307
4409
  Addresses = "addresses",
3308
4410
  BlockNumber = "blockNumber",
4411
+ LogIndex = "logIndex",
4412
+ Order = "order",
3309
4413
  App = "app",
3310
4414
  Reason = "reason"
3311
4415
  }
@@ -3318,6 +4422,8 @@ export declare type MintedEvent = Event & {
3318
4422
  /** Holds the token, operator and to addresses. */
3319
4423
  addresses: Array<Scalars['Bytes']>;
3320
4424
  blockNumber: Scalars['BigInt'];
4425
+ logIndex: Scalars['BigInt'];
4426
+ order: Scalars['BigInt'];
3321
4427
  operator: Scalars['Bytes'];
3322
4428
  to: Scalars['Bytes'];
3323
4429
  amount: Scalars['BigInt'];
@@ -3381,6 +4487,22 @@ export declare type MintedEvent_Filter = {
3381
4487
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3382
4488
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3383
4489
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
4490
+ logIndex?: Maybe<Scalars['BigInt']>;
4491
+ logIndex_not?: Maybe<Scalars['BigInt']>;
4492
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
4493
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
4494
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
4495
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
4496
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
4497
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
4498
+ order?: Maybe<Scalars['BigInt']>;
4499
+ order_not?: Maybe<Scalars['BigInt']>;
4500
+ order_gt?: Maybe<Scalars['BigInt']>;
4501
+ order_lt?: Maybe<Scalars['BigInt']>;
4502
+ order_gte?: Maybe<Scalars['BigInt']>;
4503
+ order_lte?: Maybe<Scalars['BigInt']>;
4504
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
4505
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
3384
4506
  operator?: Maybe<Scalars['Bytes']>;
3385
4507
  operator_not?: Maybe<Scalars['Bytes']>;
3386
4508
  operator_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3423,6 +4545,8 @@ export declare enum MintedEvent_OrderBy {
3423
4545
  Name = "name",
3424
4546
  Addresses = "addresses",
3425
4547
  BlockNumber = "blockNumber",
4548
+ LogIndex = "logIndex",
4549
+ Order = "order",
3426
4550
  Operator = "operator",
3427
4551
  To = "to",
3428
4552
  Amount = "amount",
@@ -3443,6 +4567,8 @@ export declare type PppConfigurationChangedEvent = Event & {
3443
4567
  /** Empty addresses array. */
3444
4568
  addresses: Array<Scalars['Bytes']>;
3445
4569
  blockNumber: Scalars['BigInt'];
4570
+ logIndex: Scalars['BigInt'];
4571
+ order: Scalars['BigInt'];
3446
4572
  host: Scalars['Bytes'];
3447
4573
  superToken: Scalars['Bytes'];
3448
4574
  isKeySet: Scalars['Boolean'];
@@ -3506,6 +4632,22 @@ export declare type PppConfigurationChangedEvent_Filter = {
3506
4632
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3507
4633
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3508
4634
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
4635
+ logIndex?: Maybe<Scalars['BigInt']>;
4636
+ logIndex_not?: Maybe<Scalars['BigInt']>;
4637
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
4638
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
4639
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
4640
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
4641
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
4642
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
4643
+ order?: Maybe<Scalars['BigInt']>;
4644
+ order_not?: Maybe<Scalars['BigInt']>;
4645
+ order_gt?: Maybe<Scalars['BigInt']>;
4646
+ order_lt?: Maybe<Scalars['BigInt']>;
4647
+ order_gte?: Maybe<Scalars['BigInt']>;
4648
+ order_lte?: Maybe<Scalars['BigInt']>;
4649
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
4650
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
3509
4651
  host?: Maybe<Scalars['Bytes']>;
3510
4652
  host_not?: Maybe<Scalars['Bytes']>;
3511
4653
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3548,6 +4690,8 @@ export declare enum PppConfigurationChangedEvent_OrderBy {
3548
4690
  Name = "name",
3549
4691
  Addresses = "addresses",
3550
4692
  BlockNumber = "blockNumber",
4693
+ LogIndex = "logIndex",
4694
+ Order = "order",
3551
4695
  Host = "host",
3552
4696
  SuperToken = "superToken",
3553
4697
  IsKeySet = "isKeySet",
@@ -3558,6 +4702,8 @@ export declare type Query = {
3558
4702
  __typename?: 'Query';
3559
4703
  flowUpdatedEvent?: Maybe<FlowUpdatedEvent>;
3560
4704
  flowUpdatedEvents: Array<FlowUpdatedEvent>;
4705
+ flowOperatorUpdatedEvent?: Maybe<FlowOperatorUpdatedEvent>;
4706
+ flowOperatorUpdatedEvents: Array<FlowOperatorUpdatedEvent>;
3561
4707
  indexCreatedEvent?: Maybe<IndexCreatedEvent>;
3562
4708
  indexCreatedEvents: Array<IndexCreatedEvent>;
3563
4709
  indexDistributionClaimedEvent?: Maybe<IndexDistributionClaimedEvent>;
@@ -3638,6 +4784,8 @@ export declare type Query = {
3638
4784
  indexSubscriptions: Array<IndexSubscription>;
3639
4785
  stream?: Maybe<Stream>;
3640
4786
  streams: Array<Stream>;
4787
+ flowOperator?: Maybe<FlowOperator>;
4788
+ flowOperators: Array<FlowOperator>;
3641
4789
  streamPeriod?: Maybe<StreamPeriod>;
3642
4790
  streamPeriods: Array<StreamPeriod>;
3643
4791
  streamRevision?: Maybe<StreamRevision>;
@@ -3646,6 +4794,8 @@ export declare type Query = {
3646
4794
  tokens: Array<Token>;
3647
4795
  accountTokenSnapshot?: Maybe<AccountTokenSnapshot>;
3648
4796
  accountTokenSnapshots: Array<AccountTokenSnapshot>;
4797
+ accountTokenSnapshotLog?: Maybe<AccountTokenSnapshotLog>;
4798
+ accountTokenSnapshotLogs: Array<AccountTokenSnapshotLog>;
3649
4799
  tokenStatistic?: Maybe<TokenStatistic>;
3650
4800
  tokenStatistics: Array<TokenStatistic>;
3651
4801
  sfmeta?: Maybe<SfMeta>;
@@ -3669,6 +4819,20 @@ export declare type QueryFlowUpdatedEventsArgs = {
3669
4819
  block?: Maybe<Block_Height>;
3670
4820
  subgraphError?: _SubgraphErrorPolicy_;
3671
4821
  };
4822
+ export declare type QueryFlowOperatorUpdatedEventArgs = {
4823
+ id: Scalars['ID'];
4824
+ block?: Maybe<Block_Height>;
4825
+ subgraphError?: _SubgraphErrorPolicy_;
4826
+ };
4827
+ export declare type QueryFlowOperatorUpdatedEventsArgs = {
4828
+ skip?: Maybe<Scalars['Int']>;
4829
+ first?: Maybe<Scalars['Int']>;
4830
+ orderBy?: Maybe<FlowOperatorUpdatedEvent_OrderBy>;
4831
+ orderDirection?: Maybe<OrderDirection>;
4832
+ where?: Maybe<FlowOperatorUpdatedEvent_Filter>;
4833
+ block?: Maybe<Block_Height>;
4834
+ subgraphError?: _SubgraphErrorPolicy_;
4835
+ };
3672
4836
  export declare type QueryIndexCreatedEventArgs = {
3673
4837
  id: Scalars['ID'];
3674
4838
  block?: Maybe<Block_Height>;
@@ -4229,6 +5393,20 @@ export declare type QueryStreamsArgs = {
4229
5393
  block?: Maybe<Block_Height>;
4230
5394
  subgraphError?: _SubgraphErrorPolicy_;
4231
5395
  };
5396
+ export declare type QueryFlowOperatorArgs = {
5397
+ id: Scalars['ID'];
5398
+ block?: Maybe<Block_Height>;
5399
+ subgraphError?: _SubgraphErrorPolicy_;
5400
+ };
5401
+ export declare type QueryFlowOperatorsArgs = {
5402
+ skip?: Maybe<Scalars['Int']>;
5403
+ first?: Maybe<Scalars['Int']>;
5404
+ orderBy?: Maybe<FlowOperator_OrderBy>;
5405
+ orderDirection?: Maybe<OrderDirection>;
5406
+ where?: Maybe<FlowOperator_Filter>;
5407
+ block?: Maybe<Block_Height>;
5408
+ subgraphError?: _SubgraphErrorPolicy_;
5409
+ };
4232
5410
  export declare type QueryStreamPeriodArgs = {
4233
5411
  id: Scalars['ID'];
4234
5412
  block?: Maybe<Block_Height>;
@@ -4285,6 +5463,20 @@ export declare type QueryAccountTokenSnapshotsArgs = {
4285
5463
  block?: Maybe<Block_Height>;
4286
5464
  subgraphError?: _SubgraphErrorPolicy_;
4287
5465
  };
5466
+ export declare type QueryAccountTokenSnapshotLogArgs = {
5467
+ id: Scalars['ID'];
5468
+ block?: Maybe<Block_Height>;
5469
+ subgraphError?: _SubgraphErrorPolicy_;
5470
+ };
5471
+ export declare type QueryAccountTokenSnapshotLogsArgs = {
5472
+ skip?: Maybe<Scalars['Int']>;
5473
+ first?: Maybe<Scalars['Int']>;
5474
+ orderBy?: Maybe<AccountTokenSnapshotLog_OrderBy>;
5475
+ orderDirection?: Maybe<OrderDirection>;
5476
+ where?: Maybe<AccountTokenSnapshotLog_Filter>;
5477
+ block?: Maybe<Block_Height>;
5478
+ subgraphError?: _SubgraphErrorPolicy_;
5479
+ };
4288
5480
  export declare type QueryTokenStatisticArgs = {
4289
5481
  id: Scalars['ID'];
4290
5482
  block?: Maybe<Block_Height>;
@@ -4339,6 +5531,8 @@ export declare type RewardAddressChangedEvent = Event & {
4339
5531
  /** Empty addresses array. */
4340
5532
  addresses: Array<Scalars['Bytes']>;
4341
5533
  blockNumber: Scalars['BigInt'];
5534
+ logIndex: Scalars['BigInt'];
5535
+ order: Scalars['BigInt'];
4342
5536
  host: Scalars['Bytes'];
4343
5537
  superToken: Scalars['Bytes'];
4344
5538
  isKeySet: Scalars['Boolean'];
@@ -4401,6 +5595,22 @@ export declare type RewardAddressChangedEvent_Filter = {
4401
5595
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4402
5596
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4403
5597
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
5598
+ logIndex?: Maybe<Scalars['BigInt']>;
5599
+ logIndex_not?: Maybe<Scalars['BigInt']>;
5600
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
5601
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
5602
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
5603
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
5604
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
5605
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
5606
+ order?: Maybe<Scalars['BigInt']>;
5607
+ order_not?: Maybe<Scalars['BigInt']>;
5608
+ order_gt?: Maybe<Scalars['BigInt']>;
5609
+ order_lt?: Maybe<Scalars['BigInt']>;
5610
+ order_gte?: Maybe<Scalars['BigInt']>;
5611
+ order_lte?: Maybe<Scalars['BigInt']>;
5612
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
5613
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
4404
5614
  host?: Maybe<Scalars['Bytes']>;
4405
5615
  host_not?: Maybe<Scalars['Bytes']>;
4406
5616
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4433,6 +5643,8 @@ export declare enum RewardAddressChangedEvent_OrderBy {
4433
5643
  Name = "name",
4434
5644
  Addresses = "addresses",
4435
5645
  BlockNumber = "blockNumber",
5646
+ LogIndex = "logIndex",
5647
+ Order = "order",
4436
5648
  Host = "host",
4437
5649
  SuperToken = "superToken",
4438
5650
  IsKeySet = "isKeySet",
@@ -4447,6 +5659,8 @@ export declare type RoleAdminChangedEvent = Event & {
4447
5659
  /** Empty addresses array. */
4448
5660
  addresses: Array<Scalars['Bytes']>;
4449
5661
  blockNumber: Scalars['BigInt'];
5662
+ logIndex: Scalars['BigInt'];
5663
+ order: Scalars['BigInt'];
4450
5664
  role: Scalars['Bytes'];
4451
5665
  previousAdminRole: Scalars['Bytes'];
4452
5666
  newAdminRole: Scalars['Bytes'];
@@ -4508,6 +5722,22 @@ export declare type RoleAdminChangedEvent_Filter = {
4508
5722
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4509
5723
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4510
5724
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
5725
+ logIndex?: Maybe<Scalars['BigInt']>;
5726
+ logIndex_not?: Maybe<Scalars['BigInt']>;
5727
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
5728
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
5729
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
5730
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
5731
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
5732
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
5733
+ order?: Maybe<Scalars['BigInt']>;
5734
+ order_not?: Maybe<Scalars['BigInt']>;
5735
+ order_gt?: Maybe<Scalars['BigInt']>;
5736
+ order_lt?: Maybe<Scalars['BigInt']>;
5737
+ order_gte?: Maybe<Scalars['BigInt']>;
5738
+ order_lte?: Maybe<Scalars['BigInt']>;
5739
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
5740
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
4511
5741
  role?: Maybe<Scalars['Bytes']>;
4512
5742
  role_not?: Maybe<Scalars['Bytes']>;
4513
5743
  role_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4536,6 +5766,8 @@ export declare enum RoleAdminChangedEvent_OrderBy {
4536
5766
  Name = "name",
4537
5767
  Addresses = "addresses",
4538
5768
  BlockNumber = "blockNumber",
5769
+ LogIndex = "logIndex",
5770
+ Order = "order",
4539
5771
  Role = "role",
4540
5772
  PreviousAdminRole = "previousAdminRole",
4541
5773
  NewAdminRole = "newAdminRole"
@@ -4549,6 +5781,8 @@ export declare type RoleGrantedEvent = Event & {
4549
5781
  /** Empty addresses array. */
4550
5782
  addresses: Array<Scalars['Bytes']>;
4551
5783
  blockNumber: Scalars['BigInt'];
5784
+ logIndex: Scalars['BigInt'];
5785
+ order: Scalars['BigInt'];
4552
5786
  role: Scalars['Bytes'];
4553
5787
  account: Scalars['Bytes'];
4554
5788
  sender: Scalars['Bytes'];
@@ -4610,6 +5844,22 @@ export declare type RoleGrantedEvent_Filter = {
4610
5844
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4611
5845
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4612
5846
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
5847
+ logIndex?: Maybe<Scalars['BigInt']>;
5848
+ logIndex_not?: Maybe<Scalars['BigInt']>;
5849
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
5850
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
5851
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
5852
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
5853
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
5854
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
5855
+ order?: Maybe<Scalars['BigInt']>;
5856
+ order_not?: Maybe<Scalars['BigInt']>;
5857
+ order_gt?: Maybe<Scalars['BigInt']>;
5858
+ order_lt?: Maybe<Scalars['BigInt']>;
5859
+ order_gte?: Maybe<Scalars['BigInt']>;
5860
+ order_lte?: Maybe<Scalars['BigInt']>;
5861
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
5862
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
4613
5863
  role?: Maybe<Scalars['Bytes']>;
4614
5864
  role_not?: Maybe<Scalars['Bytes']>;
4615
5865
  role_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4638,6 +5888,8 @@ export declare enum RoleGrantedEvent_OrderBy {
4638
5888
  Name = "name",
4639
5889
  Addresses = "addresses",
4640
5890
  BlockNumber = "blockNumber",
5891
+ LogIndex = "logIndex",
5892
+ Order = "order",
4641
5893
  Role = "role",
4642
5894
  Account = "account",
4643
5895
  Sender = "sender"
@@ -4651,6 +5903,8 @@ export declare type RoleRevokedEvent = Event & {
4651
5903
  /** Empty addresses array. */
4652
5904
  addresses: Array<Scalars['Bytes']>;
4653
5905
  blockNumber: Scalars['BigInt'];
5906
+ logIndex: Scalars['BigInt'];
5907
+ order: Scalars['BigInt'];
4654
5908
  role: Scalars['Bytes'];
4655
5909
  account: Scalars['Bytes'];
4656
5910
  sender: Scalars['Bytes'];
@@ -4712,6 +5966,22 @@ export declare type RoleRevokedEvent_Filter = {
4712
5966
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4713
5967
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4714
5968
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
5969
+ logIndex?: Maybe<Scalars['BigInt']>;
5970
+ logIndex_not?: Maybe<Scalars['BigInt']>;
5971
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
5972
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
5973
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
5974
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
5975
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
5976
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
5977
+ order?: Maybe<Scalars['BigInt']>;
5978
+ order_not?: Maybe<Scalars['BigInt']>;
5979
+ order_gt?: Maybe<Scalars['BigInt']>;
5980
+ order_lt?: Maybe<Scalars['BigInt']>;
5981
+ order_gte?: Maybe<Scalars['BigInt']>;
5982
+ order_lte?: Maybe<Scalars['BigInt']>;
5983
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
5984
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
4715
5985
  role?: Maybe<Scalars['Bytes']>;
4716
5986
  role_not?: Maybe<Scalars['Bytes']>;
4717
5987
  role_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4740,6 +6010,8 @@ export declare enum RoleRevokedEvent_OrderBy {
4740
6010
  Name = "name",
4741
6011
  Addresses = "addresses",
4742
6012
  BlockNumber = "blockNumber",
6013
+ LogIndex = "logIndex",
6014
+ Order = "order",
4743
6015
  Role = "role",
4744
6016
  Account = "account",
4745
6017
  Sender = "sender"
@@ -4839,6 +6111,8 @@ export declare type SentEvent = Event & {
4839
6111
  /** Holds the token, operator and from addresses. */
4840
6112
  addresses: Array<Scalars['Bytes']>;
4841
6113
  blockNumber: Scalars['BigInt'];
6114
+ logIndex: Scalars['BigInt'];
6115
+ order: Scalars['BigInt'];
4842
6116
  operator: Scalars['Bytes'];
4843
6117
  from: Scalars['Bytes'];
4844
6118
  to: Scalars['Bytes'];
@@ -4903,6 +6177,22 @@ export declare type SentEvent_Filter = {
4903
6177
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4904
6178
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4905
6179
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
6180
+ logIndex?: Maybe<Scalars['BigInt']>;
6181
+ logIndex_not?: Maybe<Scalars['BigInt']>;
6182
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
6183
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
6184
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
6185
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
6186
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
6187
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
6188
+ order?: Maybe<Scalars['BigInt']>;
6189
+ order_not?: Maybe<Scalars['BigInt']>;
6190
+ order_gt?: Maybe<Scalars['BigInt']>;
6191
+ order_lt?: Maybe<Scalars['BigInt']>;
6192
+ order_gte?: Maybe<Scalars['BigInt']>;
6193
+ order_lte?: Maybe<Scalars['BigInt']>;
6194
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
6195
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
4906
6196
  operator?: Maybe<Scalars['Bytes']>;
4907
6197
  operator_not?: Maybe<Scalars['Bytes']>;
4908
6198
  operator_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4951,6 +6241,8 @@ export declare enum SentEvent_OrderBy {
4951
6241
  Name = "name",
4952
6242
  Addresses = "addresses",
4953
6243
  BlockNumber = "blockNumber",
6244
+ LogIndex = "logIndex",
6245
+ Order = "order",
4954
6246
  Operator = "operator",
4955
6247
  From = "from",
4956
6248
  To = "to",
@@ -4959,7 +6251,7 @@ export declare enum SentEvent_OrderBy {
4959
6251
  OperatorData = "operatorData"
4960
6252
  }
4961
6253
  /**
4962
- * Stream: A HOL entity that represents the lifetime of a stream between a `sender` and a `receiver`.
6254
+ * Stream: A higher order entity that represents the lifetime of a stream between a `sender` and a `receiver`.
4963
6255
  * A account can start a stream, update the flow rate, but when they close it, it is
4964
6256
  * considered "dead". The next stream you create with the same `sender` and `receiver`
4965
6257
  * will create a new stream entity. Therefore, multiple stream entities can be created
@@ -4974,6 +6266,7 @@ export declare type Stream = {
4974
6266
  updatedAtTimestamp: Scalars['BigInt'];
4975
6267
  updatedAtBlockNumber: Scalars['BigInt'];
4976
6268
  currentFlowRate: Scalars['BigInt'];
6269
+ deposit: Scalars['BigInt'];
4977
6270
  /**
4978
6271
  * The amount streamed until `updatedAtTimestamp`/`updatedAtBlock`. The formula to get the current streamed
4979
6272
  * amount is:
@@ -4987,7 +6280,7 @@ export declare type Stream = {
4987
6280
  streamPeriods: Array<StreamPeriod>;
4988
6281
  };
4989
6282
  /**
4990
- * Stream: A HOL entity that represents the lifetime of a stream between a `sender` and a `receiver`.
6283
+ * Stream: A higher order entity that represents the lifetime of a stream between a `sender` and a `receiver`.
4991
6284
  * A account can start a stream, update the flow rate, but when they close it, it is
4992
6285
  * considered "dead". The next stream you create with the same `sender` and `receiver`
4993
6286
  * will create a new stream entity. Therefore, multiple stream entities can be created
@@ -5001,7 +6294,7 @@ export declare type StreamFlowUpdatedEventsArgs = {
5001
6294
  where?: Maybe<FlowUpdatedEvent_Filter>;
5002
6295
  };
5003
6296
  /**
5004
- * Stream: A HOL entity that represents the lifetime of a stream between a `sender` and a `receiver`.
6297
+ * Stream: A higher order entity that represents the lifetime of a stream between a `sender` and a `receiver`.
5005
6298
  * A account can start a stream, update the flow rate, but when they close it, it is
5006
6299
  * considered "dead". The next stream you create with the same `sender` and `receiver`
5007
6300
  * will create a new stream entity. Therefore, multiple stream entities can be created
@@ -5014,7 +6307,7 @@ export declare type StreamStreamPeriodsArgs = {
5014
6307
  orderDirection?: Maybe<OrderDirection>;
5015
6308
  where?: Maybe<StreamPeriod_Filter>;
5016
6309
  };
5017
- /** StreamPeriod: A HOL entity that represents a period of time in a Stream with a constant flowRate. */
6310
+ /** StreamPeriod: A higher order entity that represents a period of time in a Stream with a constant flowRate. */
5018
6311
  export declare type StreamPeriod = {
5019
6312
  __typename?: 'StreamPeriod';
5020
6313
  /** ID composed of: streamId - periodRevisionIndex */
@@ -5024,6 +6317,7 @@ export declare type StreamPeriod = {
5024
6317
  receiver: Account;
5025
6318
  token: Token;
5026
6319
  flowRate: Scalars['BigInt'];
6320
+ deposit: Scalars['BigInt'];
5027
6321
  startedAtTimestamp: Scalars['BigInt'];
5028
6322
  startedAtBlockNumber: Scalars['BigInt'];
5029
6323
  startedAtEvent: FlowUpdatedEvent;
@@ -5130,6 +6424,14 @@ export declare type StreamPeriod_Filter = {
5130
6424
  flowRate_lte?: Maybe<Scalars['BigInt']>;
5131
6425
  flowRate_in?: Maybe<Array<Scalars['BigInt']>>;
5132
6426
  flowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
6427
+ deposit?: Maybe<Scalars['BigInt']>;
6428
+ deposit_not?: Maybe<Scalars['BigInt']>;
6429
+ deposit_gt?: Maybe<Scalars['BigInt']>;
6430
+ deposit_lt?: Maybe<Scalars['BigInt']>;
6431
+ deposit_gte?: Maybe<Scalars['BigInt']>;
6432
+ deposit_lte?: Maybe<Scalars['BigInt']>;
6433
+ deposit_in?: Maybe<Array<Scalars['BigInt']>>;
6434
+ deposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
5133
6435
  startedAtTimestamp?: Maybe<Scalars['BigInt']>;
5134
6436
  startedAtTimestamp_not?: Maybe<Scalars['BigInt']>;
5135
6437
  startedAtTimestamp_gt?: Maybe<Scalars['BigInt']>;
@@ -5220,6 +6522,7 @@ export declare enum StreamPeriod_OrderBy {
5220
6522
  Receiver = "receiver",
5221
6523
  Token = "token",
5222
6524
  FlowRate = "flowRate",
6525
+ Deposit = "deposit",
5223
6526
  StartedAtTimestamp = "startedAtTimestamp",
5224
6527
  StartedAtBlockNumber = "startedAtBlockNumber",
5225
6528
  StartedAtEvent = "startedAtEvent",
@@ -5316,6 +6619,14 @@ export declare type Stream_Filter = {
5316
6619
  currentFlowRate_lte?: Maybe<Scalars['BigInt']>;
5317
6620
  currentFlowRate_in?: Maybe<Array<Scalars['BigInt']>>;
5318
6621
  currentFlowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
6622
+ deposit?: Maybe<Scalars['BigInt']>;
6623
+ deposit_not?: Maybe<Scalars['BigInt']>;
6624
+ deposit_gt?: Maybe<Scalars['BigInt']>;
6625
+ deposit_lt?: Maybe<Scalars['BigInt']>;
6626
+ deposit_gte?: Maybe<Scalars['BigInt']>;
6627
+ deposit_lte?: Maybe<Scalars['BigInt']>;
6628
+ deposit_in?: Maybe<Array<Scalars['BigInt']>>;
6629
+ deposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
5319
6630
  streamedUntilUpdatedAt?: Maybe<Scalars['BigInt']>;
5320
6631
  streamedUntilUpdatedAt_not?: Maybe<Scalars['BigInt']>;
5321
6632
  streamedUntilUpdatedAt_gt?: Maybe<Scalars['BigInt']>;
@@ -5394,6 +6705,7 @@ export declare enum Stream_OrderBy {
5394
6705
  UpdatedAtTimestamp = "updatedAtTimestamp",
5395
6706
  UpdatedAtBlockNumber = "updatedAtBlockNumber",
5396
6707
  CurrentFlowRate = "currentFlowRate",
6708
+ Deposit = "deposit",
5397
6709
  StreamedUntilUpdatedAt = "streamedUntilUpdatedAt",
5398
6710
  Token = "token",
5399
6711
  Sender = "sender",
@@ -5405,6 +6717,8 @@ export declare type Subscription = {
5405
6717
  __typename?: 'Subscription';
5406
6718
  flowUpdatedEvent?: Maybe<FlowUpdatedEvent>;
5407
6719
  flowUpdatedEvents: Array<FlowUpdatedEvent>;
6720
+ flowOperatorUpdatedEvent?: Maybe<FlowOperatorUpdatedEvent>;
6721
+ flowOperatorUpdatedEvents: Array<FlowOperatorUpdatedEvent>;
5408
6722
  indexCreatedEvent?: Maybe<IndexCreatedEvent>;
5409
6723
  indexCreatedEvents: Array<IndexCreatedEvent>;
5410
6724
  indexDistributionClaimedEvent?: Maybe<IndexDistributionClaimedEvent>;
@@ -5485,6 +6799,8 @@ export declare type Subscription = {
5485
6799
  indexSubscriptions: Array<IndexSubscription>;
5486
6800
  stream?: Maybe<Stream>;
5487
6801
  streams: Array<Stream>;
6802
+ flowOperator?: Maybe<FlowOperator>;
6803
+ flowOperators: Array<FlowOperator>;
5488
6804
  streamPeriod?: Maybe<StreamPeriod>;
5489
6805
  streamPeriods: Array<StreamPeriod>;
5490
6806
  streamRevision?: Maybe<StreamRevision>;
@@ -5493,6 +6809,8 @@ export declare type Subscription = {
5493
6809
  tokens: Array<Token>;
5494
6810
  accountTokenSnapshot?: Maybe<AccountTokenSnapshot>;
5495
6811
  accountTokenSnapshots: Array<AccountTokenSnapshot>;
6812
+ accountTokenSnapshotLog?: Maybe<AccountTokenSnapshotLog>;
6813
+ accountTokenSnapshotLogs: Array<AccountTokenSnapshotLog>;
5496
6814
  tokenStatistic?: Maybe<TokenStatistic>;
5497
6815
  tokenStatistics: Array<TokenStatistic>;
5498
6816
  sfmeta?: Maybe<SfMeta>;
@@ -5516,6 +6834,20 @@ export declare type SubscriptionFlowUpdatedEventsArgs = {
5516
6834
  block?: Maybe<Block_Height>;
5517
6835
  subgraphError?: _SubgraphErrorPolicy_;
5518
6836
  };
6837
+ export declare type SubscriptionFlowOperatorUpdatedEventArgs = {
6838
+ id: Scalars['ID'];
6839
+ block?: Maybe<Block_Height>;
6840
+ subgraphError?: _SubgraphErrorPolicy_;
6841
+ };
6842
+ export declare type SubscriptionFlowOperatorUpdatedEventsArgs = {
6843
+ skip?: Maybe<Scalars['Int']>;
6844
+ first?: Maybe<Scalars['Int']>;
6845
+ orderBy?: Maybe<FlowOperatorUpdatedEvent_OrderBy>;
6846
+ orderDirection?: Maybe<OrderDirection>;
6847
+ where?: Maybe<FlowOperatorUpdatedEvent_Filter>;
6848
+ block?: Maybe<Block_Height>;
6849
+ subgraphError?: _SubgraphErrorPolicy_;
6850
+ };
5519
6851
  export declare type SubscriptionIndexCreatedEventArgs = {
5520
6852
  id: Scalars['ID'];
5521
6853
  block?: Maybe<Block_Height>;
@@ -6076,6 +7408,20 @@ export declare type SubscriptionStreamsArgs = {
6076
7408
  block?: Maybe<Block_Height>;
6077
7409
  subgraphError?: _SubgraphErrorPolicy_;
6078
7410
  };
7411
+ export declare type SubscriptionFlowOperatorArgs = {
7412
+ id: Scalars['ID'];
7413
+ block?: Maybe<Block_Height>;
7414
+ subgraphError?: _SubgraphErrorPolicy_;
7415
+ };
7416
+ export declare type SubscriptionFlowOperatorsArgs = {
7417
+ skip?: Maybe<Scalars['Int']>;
7418
+ first?: Maybe<Scalars['Int']>;
7419
+ orderBy?: Maybe<FlowOperator_OrderBy>;
7420
+ orderDirection?: Maybe<OrderDirection>;
7421
+ where?: Maybe<FlowOperator_Filter>;
7422
+ block?: Maybe<Block_Height>;
7423
+ subgraphError?: _SubgraphErrorPolicy_;
7424
+ };
6079
7425
  export declare type SubscriptionStreamPeriodArgs = {
6080
7426
  id: Scalars['ID'];
6081
7427
  block?: Maybe<Block_Height>;
@@ -6132,6 +7478,20 @@ export declare type SubscriptionAccountTokenSnapshotsArgs = {
6132
7478
  block?: Maybe<Block_Height>;
6133
7479
  subgraphError?: _SubgraphErrorPolicy_;
6134
7480
  };
7481
+ export declare type SubscriptionAccountTokenSnapshotLogArgs = {
7482
+ id: Scalars['ID'];
7483
+ block?: Maybe<Block_Height>;
7484
+ subgraphError?: _SubgraphErrorPolicy_;
7485
+ };
7486
+ export declare type SubscriptionAccountTokenSnapshotLogsArgs = {
7487
+ skip?: Maybe<Scalars['Int']>;
7488
+ first?: Maybe<Scalars['Int']>;
7489
+ orderBy?: Maybe<AccountTokenSnapshotLog_OrderBy>;
7490
+ orderDirection?: Maybe<OrderDirection>;
7491
+ where?: Maybe<AccountTokenSnapshotLog_Filter>;
7492
+ block?: Maybe<Block_Height>;
7493
+ subgraphError?: _SubgraphErrorPolicy_;
7494
+ };
6135
7495
  export declare type SubscriptionTokenStatisticArgs = {
6136
7496
  id: Scalars['ID'];
6137
7497
  block?: Maybe<Block_Height>;
@@ -6186,6 +7546,8 @@ export declare type SubscriptionApprovedEvent = Event & {
6186
7546
  /** Holds the token, publisher and subscriber addresses. */
6187
7547
  addresses: Array<Scalars['Bytes']>;
6188
7548
  blockNumber: Scalars['BigInt'];
7549
+ logIndex: Scalars['BigInt'];
7550
+ order: Scalars['BigInt'];
6189
7551
  token: Scalars['Bytes'];
6190
7552
  subscriber: Scalars['Bytes'];
6191
7553
  publisher: Scalars['Bytes'];
@@ -6250,6 +7612,22 @@ export declare type SubscriptionApprovedEvent_Filter = {
6250
7612
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6251
7613
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6252
7614
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
7615
+ logIndex?: Maybe<Scalars['BigInt']>;
7616
+ logIndex_not?: Maybe<Scalars['BigInt']>;
7617
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
7618
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
7619
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
7620
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
7621
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
7622
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
7623
+ order?: Maybe<Scalars['BigInt']>;
7624
+ order_not?: Maybe<Scalars['BigInt']>;
7625
+ order_gt?: Maybe<Scalars['BigInt']>;
7626
+ order_lt?: Maybe<Scalars['BigInt']>;
7627
+ order_gte?: Maybe<Scalars['BigInt']>;
7628
+ order_lte?: Maybe<Scalars['BigInt']>;
7629
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
7630
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
6253
7631
  token?: Maybe<Scalars['Bytes']>;
6254
7632
  token_not?: Maybe<Scalars['Bytes']>;
6255
7633
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6312,6 +7690,8 @@ export declare enum SubscriptionApprovedEvent_OrderBy {
6312
7690
  Name = "name",
6313
7691
  Addresses = "addresses",
6314
7692
  BlockNumber = "blockNumber",
7693
+ LogIndex = "logIndex",
7694
+ Order = "order",
6315
7695
  Token = "token",
6316
7696
  Subscriber = "subscriber",
6317
7697
  Publisher = "publisher",
@@ -6328,6 +7708,8 @@ export declare type SubscriptionDistributionClaimedEvent = Event & {
6328
7708
  /** Holds the token, publisher and subscriber addresses. */
6329
7709
  addresses: Array<Scalars['Bytes']>;
6330
7710
  blockNumber: Scalars['BigInt'];
7711
+ logIndex: Scalars['BigInt'];
7712
+ order: Scalars['BigInt'];
6331
7713
  token: Scalars['Bytes'];
6332
7714
  subscriber: Scalars['Bytes'];
6333
7715
  publisher: Scalars['Bytes'];
@@ -6392,6 +7774,22 @@ export declare type SubscriptionDistributionClaimedEvent_Filter = {
6392
7774
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6393
7775
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6394
7776
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
7777
+ logIndex?: Maybe<Scalars['BigInt']>;
7778
+ logIndex_not?: Maybe<Scalars['BigInt']>;
7779
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
7780
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
7781
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
7782
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
7783
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
7784
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
7785
+ order?: Maybe<Scalars['BigInt']>;
7786
+ order_not?: Maybe<Scalars['BigInt']>;
7787
+ order_gt?: Maybe<Scalars['BigInt']>;
7788
+ order_lt?: Maybe<Scalars['BigInt']>;
7789
+ order_gte?: Maybe<Scalars['BigInt']>;
7790
+ order_lte?: Maybe<Scalars['BigInt']>;
7791
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
7792
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
6395
7793
  token?: Maybe<Scalars['Bytes']>;
6396
7794
  token_not?: Maybe<Scalars['Bytes']>;
6397
7795
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6456,6 +7854,8 @@ export declare enum SubscriptionDistributionClaimedEvent_OrderBy {
6456
7854
  Name = "name",
6457
7855
  Addresses = "addresses",
6458
7856
  BlockNumber = "blockNumber",
7857
+ LogIndex = "logIndex",
7858
+ Order = "order",
6459
7859
  Token = "token",
6460
7860
  Subscriber = "subscriber",
6461
7861
  Publisher = "publisher",
@@ -6472,6 +7872,8 @@ export declare type SubscriptionRevokedEvent = Event & {
6472
7872
  /** Holds the token, publisher and subscriber addresses. */
6473
7873
  addresses: Array<Scalars['Bytes']>;
6474
7874
  blockNumber: Scalars['BigInt'];
7875
+ logIndex: Scalars['BigInt'];
7876
+ order: Scalars['BigInt'];
6475
7877
  token: Scalars['Bytes'];
6476
7878
  subscriber: Scalars['Bytes'];
6477
7879
  publisher: Scalars['Bytes'];
@@ -6536,6 +7938,22 @@ export declare type SubscriptionRevokedEvent_Filter = {
6536
7938
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6537
7939
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6538
7940
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
7941
+ logIndex?: Maybe<Scalars['BigInt']>;
7942
+ logIndex_not?: Maybe<Scalars['BigInt']>;
7943
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
7944
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
7945
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
7946
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
7947
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
7948
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
7949
+ order?: Maybe<Scalars['BigInt']>;
7950
+ order_not?: Maybe<Scalars['BigInt']>;
7951
+ order_gt?: Maybe<Scalars['BigInt']>;
7952
+ order_lt?: Maybe<Scalars['BigInt']>;
7953
+ order_gte?: Maybe<Scalars['BigInt']>;
7954
+ order_lte?: Maybe<Scalars['BigInt']>;
7955
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
7956
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
6539
7957
  token?: Maybe<Scalars['Bytes']>;
6540
7958
  token_not?: Maybe<Scalars['Bytes']>;
6541
7959
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6598,6 +8016,8 @@ export declare enum SubscriptionRevokedEvent_OrderBy {
6598
8016
  Name = "name",
6599
8017
  Addresses = "addresses",
6600
8018
  BlockNumber = "blockNumber",
8019
+ LogIndex = "logIndex",
8020
+ Order = "order",
6601
8021
  Token = "token",
6602
8022
  Subscriber = "subscriber",
6603
8023
  Publisher = "publisher",
@@ -6614,6 +8034,8 @@ export declare type SubscriptionUnitsUpdatedEvent = Event & {
6614
8034
  /** Holds the token, publisher and subscriber addresses. */
6615
8035
  addresses: Array<Scalars['Bytes']>;
6616
8036
  blockNumber: Scalars['BigInt'];
8037
+ logIndex: Scalars['BigInt'];
8038
+ order: Scalars['BigInt'];
6617
8039
  token: Scalars['Bytes'];
6618
8040
  subscriber: Scalars['Bytes'];
6619
8041
  publisher: Scalars['Bytes'];
@@ -6680,6 +8102,22 @@ export declare type SubscriptionUnitsUpdatedEvent_Filter = {
6680
8102
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6681
8103
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6682
8104
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8105
+ logIndex?: Maybe<Scalars['BigInt']>;
8106
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8107
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8108
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8109
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8110
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8111
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8112
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8113
+ order?: Maybe<Scalars['BigInt']>;
8114
+ order_not?: Maybe<Scalars['BigInt']>;
8115
+ order_gt?: Maybe<Scalars['BigInt']>;
8116
+ order_lt?: Maybe<Scalars['BigInt']>;
8117
+ order_gte?: Maybe<Scalars['BigInt']>;
8118
+ order_lte?: Maybe<Scalars['BigInt']>;
8119
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8120
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
6683
8121
  token?: Maybe<Scalars['Bytes']>;
6684
8122
  token_not?: Maybe<Scalars['Bytes']>;
6685
8123
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6758,6 +8196,8 @@ export declare enum SubscriptionUnitsUpdatedEvent_OrderBy {
6758
8196
  Name = "name",
6759
8197
  Addresses = "addresses",
6760
8198
  BlockNumber = "blockNumber",
8199
+ LogIndex = "logIndex",
8200
+ Order = "order",
6761
8201
  Token = "token",
6762
8202
  Subscriber = "subscriber",
6763
8203
  Publisher = "publisher",
@@ -6776,6 +8216,8 @@ export declare type SuperTokenCreatedEvent = Event & {
6776
8216
  /** Holds the token address. */
6777
8217
  addresses: Array<Scalars['Bytes']>;
6778
8218
  blockNumber: Scalars['BigInt'];
8219
+ logIndex: Scalars['BigInt'];
8220
+ order: Scalars['BigInt'];
6779
8221
  token: Scalars['Bytes'];
6780
8222
  };
6781
8223
  export declare type SuperTokenCreatedEvent_Filter = {
@@ -6835,6 +8277,22 @@ export declare type SuperTokenCreatedEvent_Filter = {
6835
8277
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6836
8278
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6837
8279
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8280
+ logIndex?: Maybe<Scalars['BigInt']>;
8281
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8282
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8283
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8284
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8285
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8286
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8287
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8288
+ order?: Maybe<Scalars['BigInt']>;
8289
+ order_not?: Maybe<Scalars['BigInt']>;
8290
+ order_gt?: Maybe<Scalars['BigInt']>;
8291
+ order_lt?: Maybe<Scalars['BigInt']>;
8292
+ order_gte?: Maybe<Scalars['BigInt']>;
8293
+ order_lte?: Maybe<Scalars['BigInt']>;
8294
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8295
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
6838
8296
  token?: Maybe<Scalars['Bytes']>;
6839
8297
  token_not?: Maybe<Scalars['Bytes']>;
6840
8298
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6851,6 +8309,8 @@ export declare enum SuperTokenCreatedEvent_OrderBy {
6851
8309
  Name = "name",
6852
8310
  Addresses = "addresses",
6853
8311
  BlockNumber = "blockNumber",
8312
+ LogIndex = "logIndex",
8313
+ Order = "order",
6854
8314
  Token = "token"
6855
8315
  }
6856
8316
  export declare type SuperTokenFactoryUpdatedEvent = Event & {
@@ -6862,6 +8322,8 @@ export declare type SuperTokenFactoryUpdatedEvent = Event & {
6862
8322
  /** Empty addresses array. */
6863
8323
  addresses: Array<Scalars['Bytes']>;
6864
8324
  blockNumber: Scalars['BigInt'];
8325
+ logIndex: Scalars['BigInt'];
8326
+ order: Scalars['BigInt'];
6865
8327
  newFactory: Scalars['Bytes'];
6866
8328
  };
6867
8329
  export declare type SuperTokenFactoryUpdatedEvent_Filter = {
@@ -6921,6 +8383,22 @@ export declare type SuperTokenFactoryUpdatedEvent_Filter = {
6921
8383
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6922
8384
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6923
8385
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8386
+ logIndex?: Maybe<Scalars['BigInt']>;
8387
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8388
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8389
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8390
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8391
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8392
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8393
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8394
+ order?: Maybe<Scalars['BigInt']>;
8395
+ order_not?: Maybe<Scalars['BigInt']>;
8396
+ order_gt?: Maybe<Scalars['BigInt']>;
8397
+ order_lt?: Maybe<Scalars['BigInt']>;
8398
+ order_gte?: Maybe<Scalars['BigInt']>;
8399
+ order_lte?: Maybe<Scalars['BigInt']>;
8400
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8401
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
6924
8402
  newFactory?: Maybe<Scalars['Bytes']>;
6925
8403
  newFactory_not?: Maybe<Scalars['Bytes']>;
6926
8404
  newFactory_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6937,6 +8415,8 @@ export declare enum SuperTokenFactoryUpdatedEvent_OrderBy {
6937
8415
  Name = "name",
6938
8416
  Addresses = "addresses",
6939
8417
  BlockNumber = "blockNumber",
8418
+ LogIndex = "logIndex",
8419
+ Order = "order",
6940
8420
  NewFactory = "newFactory"
6941
8421
  }
6942
8422
  export declare type SuperTokenLogicCreatedEvent = Event & {
@@ -6948,6 +8428,8 @@ export declare type SuperTokenLogicCreatedEvent = Event & {
6948
8428
  /** Empty addresses array. */
6949
8429
  addresses: Array<Scalars['Bytes']>;
6950
8430
  blockNumber: Scalars['BigInt'];
8431
+ logIndex: Scalars['BigInt'];
8432
+ order: Scalars['BigInt'];
6951
8433
  tokenLogic: Scalars['Bytes'];
6952
8434
  };
6953
8435
  export declare type SuperTokenLogicCreatedEvent_Filter = {
@@ -7007,6 +8489,22 @@ export declare type SuperTokenLogicCreatedEvent_Filter = {
7007
8489
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7008
8490
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7009
8491
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8492
+ logIndex?: Maybe<Scalars['BigInt']>;
8493
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8494
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8495
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8496
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8497
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8498
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8499
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8500
+ order?: Maybe<Scalars['BigInt']>;
8501
+ order_not?: Maybe<Scalars['BigInt']>;
8502
+ order_gt?: Maybe<Scalars['BigInt']>;
8503
+ order_lt?: Maybe<Scalars['BigInt']>;
8504
+ order_gte?: Maybe<Scalars['BigInt']>;
8505
+ order_lte?: Maybe<Scalars['BigInt']>;
8506
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8507
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
7010
8508
  tokenLogic?: Maybe<Scalars['Bytes']>;
7011
8509
  tokenLogic_not?: Maybe<Scalars['Bytes']>;
7012
8510
  tokenLogic_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7023,6 +8521,8 @@ export declare enum SuperTokenLogicCreatedEvent_OrderBy {
7023
8521
  Name = "name",
7024
8522
  Addresses = "addresses",
7025
8523
  BlockNumber = "blockNumber",
8524
+ LogIndex = "logIndex",
8525
+ Order = "order",
7026
8526
  TokenLogic = "tokenLogic"
7027
8527
  }
7028
8528
  export declare type SuperTokenLogicUpdatedEvent = Event & {
@@ -7034,6 +8534,8 @@ export declare type SuperTokenLogicUpdatedEvent = Event & {
7034
8534
  /** Empty addresses array. */
7035
8535
  addresses: Array<Scalars['Bytes']>;
7036
8536
  blockNumber: Scalars['BigInt'];
8537
+ logIndex: Scalars['BigInt'];
8538
+ order: Scalars['BigInt'];
7037
8539
  token: Scalars['Bytes'];
7038
8540
  code: Scalars['Bytes'];
7039
8541
  };
@@ -7094,6 +8596,22 @@ export declare type SuperTokenLogicUpdatedEvent_Filter = {
7094
8596
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7095
8597
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7096
8598
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8599
+ logIndex?: Maybe<Scalars['BigInt']>;
8600
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8601
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8602
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8603
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8604
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8605
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8606
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8607
+ order?: Maybe<Scalars['BigInt']>;
8608
+ order_not?: Maybe<Scalars['BigInt']>;
8609
+ order_gt?: Maybe<Scalars['BigInt']>;
8610
+ order_lt?: Maybe<Scalars['BigInt']>;
8611
+ order_gte?: Maybe<Scalars['BigInt']>;
8612
+ order_lte?: Maybe<Scalars['BigInt']>;
8613
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8614
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
7097
8615
  token?: Maybe<Scalars['Bytes']>;
7098
8616
  token_not?: Maybe<Scalars['Bytes']>;
7099
8617
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7116,11 +8634,13 @@ export declare enum SuperTokenLogicUpdatedEvent_OrderBy {
7116
8634
  Name = "name",
7117
8635
  Addresses = "addresses",
7118
8636
  BlockNumber = "blockNumber",
8637
+ LogIndex = "logIndex",
8638
+ Order = "order",
7119
8639
  Token = "token",
7120
8640
  Code = "code"
7121
8641
  }
7122
8642
  /**
7123
- * Token: A HOL entity created for super tokens that are "valid" (tokens that have
8643
+ * Token: A higher order entity created for super tokens that are "valid" (tokens that have
7124
8644
  * Superfluid's host contract address set as the host).
7125
8645
  */
7126
8646
  export declare type Token = {
@@ -7153,6 +8673,8 @@ export declare type TokenDowngradedEvent = Event & {
7153
8673
  /** Holds the token and account addresses. */
7154
8674
  addresses: Array<Scalars['Bytes']>;
7155
8675
  blockNumber: Scalars['BigInt'];
8676
+ logIndex: Scalars['BigInt'];
8677
+ order: Scalars['BigInt'];
7156
8678
  token: Scalars['Bytes'];
7157
8679
  amount: Scalars['BigInt'];
7158
8680
  };
@@ -7233,6 +8755,22 @@ export declare type TokenDowngradedEvent_Filter = {
7233
8755
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7234
8756
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7235
8757
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8758
+ logIndex?: Maybe<Scalars['BigInt']>;
8759
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8760
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8761
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8762
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8763
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8764
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8765
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8766
+ order?: Maybe<Scalars['BigInt']>;
8767
+ order_not?: Maybe<Scalars['BigInt']>;
8768
+ order_gt?: Maybe<Scalars['BigInt']>;
8769
+ order_lt?: Maybe<Scalars['BigInt']>;
8770
+ order_gte?: Maybe<Scalars['BigInt']>;
8771
+ order_lte?: Maybe<Scalars['BigInt']>;
8772
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8773
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
7236
8774
  token?: Maybe<Scalars['Bytes']>;
7237
8775
  token_not?: Maybe<Scalars['Bytes']>;
7238
8776
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7258,13 +8796,15 @@ export declare enum TokenDowngradedEvent_OrderBy {
7258
8796
  Name = "name",
7259
8797
  Addresses = "addresses",
7260
8798
  BlockNumber = "blockNumber",
8799
+ LogIndex = "logIndex",
8800
+ Order = "order",
7261
8801
  Token = "token",
7262
8802
  Amount = "amount"
7263
8803
  }
7264
8804
  /** TokenStatistic: An aggregate entity which aggregates data of a single `token`. */
7265
8805
  export declare type TokenStatistic = {
7266
8806
  __typename?: 'TokenStatistic';
7267
- /** ID: tokenID */
8807
+ /** id: token address */
7268
8808
  id: Scalars['ID'];
7269
8809
  updatedAtTimestamp: Scalars['BigInt'];
7270
8810
  updatedAtBlockNumber: Scalars['BigInt'];
@@ -7286,6 +8826,8 @@ export declare type TokenStatistic = {
7286
8826
  totalSubscriptionsWithUnits: Scalars['Int'];
7287
8827
  /** Counts all approved subscriptions whether or not they have units. */
7288
8828
  totalApprovedSubscriptions: Scalars['Int'];
8829
+ /** The total deposit held by the CFA agreement for this particular `token`. */
8830
+ totalDeposit: Scalars['BigInt'];
7289
8831
  /** The total outflow rate of the `token` (how much value is being moved). */
7290
8832
  totalOutflowRate: Scalars['BigInt'];
7291
8833
  /** The all-time total amount streamed until the `updatedAtTimestamp`/`updatedAtBlock`. */
@@ -7374,6 +8916,14 @@ export declare type TokenStatistic_Filter = {
7374
8916
  totalApprovedSubscriptions_lte?: Maybe<Scalars['Int']>;
7375
8917
  totalApprovedSubscriptions_in?: Maybe<Array<Scalars['Int']>>;
7376
8918
  totalApprovedSubscriptions_not_in?: Maybe<Array<Scalars['Int']>>;
8919
+ totalDeposit?: Maybe<Scalars['BigInt']>;
8920
+ totalDeposit_not?: Maybe<Scalars['BigInt']>;
8921
+ totalDeposit_gt?: Maybe<Scalars['BigInt']>;
8922
+ totalDeposit_lt?: Maybe<Scalars['BigInt']>;
8923
+ totalDeposit_gte?: Maybe<Scalars['BigInt']>;
8924
+ totalDeposit_lte?: Maybe<Scalars['BigInt']>;
8925
+ totalDeposit_in?: Maybe<Array<Scalars['BigInt']>>;
8926
+ totalDeposit_not_in?: Maybe<Array<Scalars['BigInt']>>;
7377
8927
  totalOutflowRate?: Maybe<Scalars['BigInt']>;
7378
8928
  totalOutflowRate_not?: Maybe<Scalars['BigInt']>;
7379
8929
  totalOutflowRate_gt?: Maybe<Scalars['BigInt']>;
@@ -7447,6 +8997,7 @@ export declare enum TokenStatistic_OrderBy {
7447
8997
  TotalNumberOfActiveIndexes = "totalNumberOfActiveIndexes",
7448
8998
  TotalSubscriptionsWithUnits = "totalSubscriptionsWithUnits",
7449
8999
  TotalApprovedSubscriptions = "totalApprovedSubscriptions",
9000
+ TotalDeposit = "totalDeposit",
7450
9001
  TotalOutflowRate = "totalOutflowRate",
7451
9002
  TotalAmountStreamedUntilUpdatedAt = "totalAmountStreamedUntilUpdatedAt",
7452
9003
  TotalAmountTransferredUntilUpdatedAt = "totalAmountTransferredUntilUpdatedAt",
@@ -7464,6 +9015,8 @@ export declare type TokenUpgradedEvent = Event & {
7464
9015
  /** Holds the token and account addresses. */
7465
9016
  addresses: Array<Scalars['Bytes']>;
7466
9017
  blockNumber: Scalars['BigInt'];
9018
+ logIndex: Scalars['BigInt'];
9019
+ order: Scalars['BigInt'];
7467
9020
  token: Scalars['Bytes'];
7468
9021
  amount: Scalars['BigInt'];
7469
9022
  };
@@ -7544,6 +9097,22 @@ export declare type TokenUpgradedEvent_Filter = {
7544
9097
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7545
9098
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7546
9099
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
9100
+ logIndex?: Maybe<Scalars['BigInt']>;
9101
+ logIndex_not?: Maybe<Scalars['BigInt']>;
9102
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
9103
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
9104
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
9105
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
9106
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
9107
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
9108
+ order?: Maybe<Scalars['BigInt']>;
9109
+ order_not?: Maybe<Scalars['BigInt']>;
9110
+ order_gt?: Maybe<Scalars['BigInt']>;
9111
+ order_lt?: Maybe<Scalars['BigInt']>;
9112
+ order_gte?: Maybe<Scalars['BigInt']>;
9113
+ order_lte?: Maybe<Scalars['BigInt']>;
9114
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
9115
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
7547
9116
  token?: Maybe<Scalars['Bytes']>;
7548
9117
  token_not?: Maybe<Scalars['Bytes']>;
7549
9118
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7569,6 +9138,8 @@ export declare enum TokenUpgradedEvent_OrderBy {
7569
9138
  Name = "name",
7570
9139
  Addresses = "addresses",
7571
9140
  BlockNumber = "blockNumber",
9141
+ LogIndex = "logIndex",
9142
+ Order = "order",
7572
9143
  Token = "token",
7573
9144
  Amount = "amount"
7574
9145
  }
@@ -7703,6 +9274,8 @@ export declare type TransferEvent = Event & {
7703
9274
  /** Holds the token, from and to addresses. */
7704
9275
  addresses: Array<Scalars['Bytes']>;
7705
9276
  blockNumber: Scalars['BigInt'];
9277
+ logIndex: Scalars['BigInt'];
9278
+ order: Scalars['BigInt'];
7706
9279
  from: Account;
7707
9280
  to: Account;
7708
9281
  value: Scalars['BigInt'];
@@ -7765,6 +9338,22 @@ export declare type TransferEvent_Filter = {
7765
9338
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7766
9339
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7767
9340
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
9341
+ logIndex?: Maybe<Scalars['BigInt']>;
9342
+ logIndex_not?: Maybe<Scalars['BigInt']>;
9343
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
9344
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
9345
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
9346
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
9347
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
9348
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
9349
+ order?: Maybe<Scalars['BigInt']>;
9350
+ order_not?: Maybe<Scalars['BigInt']>;
9351
+ order_gt?: Maybe<Scalars['BigInt']>;
9352
+ order_lt?: Maybe<Scalars['BigInt']>;
9353
+ order_gte?: Maybe<Scalars['BigInt']>;
9354
+ order_lte?: Maybe<Scalars['BigInt']>;
9355
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
9356
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
7768
9357
  from?: Maybe<Scalars['String']>;
7769
9358
  from_not?: Maybe<Scalars['String']>;
7770
9359
  from_gt?: Maybe<Scalars['String']>;
@@ -7829,6 +9418,8 @@ export declare enum TransferEvent_OrderBy {
7829
9418
  Name = "name",
7830
9419
  Addresses = "addresses",
7831
9420
  BlockNumber = "blockNumber",
9421
+ LogIndex = "logIndex",
9422
+ Order = "order",
7832
9423
  From = "from",
7833
9424
  To = "to",
7834
9425
  Value = "value",
@@ -7843,6 +9434,8 @@ export declare type TrustedForwarderChangedEvent = Event & {
7843
9434
  /** Empty addresses array. */
7844
9435
  addresses: Array<Scalars['Bytes']>;
7845
9436
  blockNumber: Scalars['BigInt'];
9437
+ logIndex: Scalars['BigInt'];
9438
+ order: Scalars['BigInt'];
7846
9439
  host: Scalars['Bytes'];
7847
9440
  superToken: Scalars['Bytes'];
7848
9441
  isKeySet: Scalars['Boolean'];
@@ -7906,6 +9499,22 @@ export declare type TrustedForwarderChangedEvent_Filter = {
7906
9499
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7907
9500
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7908
9501
  blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
9502
+ logIndex?: Maybe<Scalars['BigInt']>;
9503
+ logIndex_not?: Maybe<Scalars['BigInt']>;
9504
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
9505
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
9506
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
9507
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
9508
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
9509
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
9510
+ order?: Maybe<Scalars['BigInt']>;
9511
+ order_not?: Maybe<Scalars['BigInt']>;
9512
+ order_gt?: Maybe<Scalars['BigInt']>;
9513
+ order_lt?: Maybe<Scalars['BigInt']>;
9514
+ order_gte?: Maybe<Scalars['BigInt']>;
9515
+ order_lte?: Maybe<Scalars['BigInt']>;
9516
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
9517
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
7909
9518
  host?: Maybe<Scalars['Bytes']>;
7910
9519
  host_not?: Maybe<Scalars['Bytes']>;
7911
9520
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7942,6 +9551,8 @@ export declare enum TrustedForwarderChangedEvent_OrderBy {
7942
9551
  Name = "name",
7943
9552
  Addresses = "addresses",
7944
9553
  BlockNumber = "blockNumber",
9554
+ LogIndex = "logIndex",
9555
+ Order = "order",
7945
9556
  Host = "host",
7946
9557
  SuperToken = "superToken",
7947
9558
  IsKeySet = "isKeySet",