@requestnetwork/payment-detection 0.35.1-next.1716 → 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 (5) hide show
  1. package/dist/thegraph/generated/graphql-superfluid.d.ts +1139 -2
  2. package/dist/thegraph/generated/graphql-superfluid.d.ts.map +1 -1
  3. package/dist/thegraph/generated/graphql-superfluid.js +108 -2
  4. package/dist/thegraph/generated/graphql-superfluid.js.map +1 -1
  5. package/package.json +7 -7
package/dist/thegraph/generated/graphql-superfluid.d.ts CHANGED
@@ -151,10 +151,17 @@ export declare type AccountAccountTokenSnapshotsArgs = {
151
151
  */
152
152
  export declare type AccountTokenSnapshot = {
153
153
  __typename?: 'AccountTokenSnapshot';
154
- /** ID composed of: accountID + keccak256("-") + tokenID */
154
+ /** ID composed of: accountID-tokenID */
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. */
@@ -183,6 +190,7 @@ export declare type AccountTokenSnapshot = {
183
190
  account: Account;
184
191
  token: Token;
185
192
  flowOperators: Array<FlowOperator>;
193
+ accountTokenSnapshotLogs: Array<AccountTokenSnapshotLog>;
186
194
  };
187
195
  /**
188
196
  * AccountTokenSnapshot: An aggregate entity which aggregates data on an account's
@@ -195,6 +203,308 @@ export declare type AccountTokenSnapshotFlowOperatorsArgs = {
195
203
  orderDirection?: Maybe<OrderDirection>;
196
204
  where?: Maybe<FlowOperator_Filter>;
197
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
+ }
198
508
  export declare type AccountTokenSnapshot_Filter = {
199
509
  id?: Maybe<Scalars['ID']>;
200
510
  id_not?: Maybe<Scalars['ID']>;
@@ -220,6 +530,18 @@ export declare type AccountTokenSnapshot_Filter = {
220
530
  updatedAtBlockNumber_lte?: Maybe<Scalars['BigInt']>;
221
531
  updatedAtBlockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
222
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']>>;
223
545
  totalNumberOfActiveStreams?: Maybe<Scalars['Int']>;
224
546
  totalNumberOfActiveStreams_not?: Maybe<Scalars['Int']>;
225
547
  totalNumberOfActiveStreams_gt?: Maybe<Scalars['Int']>;
@@ -355,6 +677,8 @@ export declare enum AccountTokenSnapshot_OrderBy {
355
677
  Id = "id",
356
678
  UpdatedAtTimestamp = "updatedAtTimestamp",
357
679
  UpdatedAtBlockNumber = "updatedAtBlockNumber",
680
+ IsLiquidationEstimateOptimistic = "isLiquidationEstimateOptimistic",
681
+ MaybeCriticalAtTimestamp = "maybeCriticalAtTimestamp",
358
682
  TotalNumberOfActiveStreams = "totalNumberOfActiveStreams",
359
683
  TotalNumberOfClosedStreams = "totalNumberOfClosedStreams",
360
684
  TotalSubscriptionsWithUnits = "totalSubscriptionsWithUnits",
@@ -368,7 +692,8 @@ export declare enum AccountTokenSnapshot_OrderBy {
368
692
  TotalAmountTransferredUntilUpdatedAt = "totalAmountTransferredUntilUpdatedAt",
369
693
  Account = "account",
370
694
  Token = "token",
371
- FlowOperators = "flowOperators"
695
+ FlowOperators = "flowOperators",
696
+ AccountTokenSnapshotLogs = "accountTokenSnapshotLogs"
372
697
  }
373
698
  export declare type Account_Filter = {
374
699
  id?: Maybe<Scalars['ID']>;
@@ -444,6 +769,8 @@ export declare type AgreementClassRegisteredEvent = Event & {
444
769
  /** Empty addresses array. */
445
770
  addresses: Array<Scalars['Bytes']>;
446
771
  blockNumber: Scalars['BigInt'];
772
+ logIndex: Scalars['BigInt'];
773
+ order: Scalars['BigInt'];
447
774
  agreementType: Scalars['Bytes'];
448
775
  code: Scalars['Bytes'];
449
776
  };
@@ -504,6 +831,22 @@ export declare type AgreementClassRegisteredEvent_Filter = {
504
831
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
505
832
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
506
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']>>;
507
850
  agreementType?: Maybe<Scalars['Bytes']>;
508
851
  agreementType_not?: Maybe<Scalars['Bytes']>;
509
852
  agreementType_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -526,6 +869,8 @@ export declare enum AgreementClassRegisteredEvent_OrderBy {
526
869
  Name = "name",
527
870
  Addresses = "addresses",
528
871
  BlockNumber = "blockNumber",
872
+ LogIndex = "logIndex",
873
+ Order = "order",
529
874
  AgreementType = "agreementType",
530
875
  Code = "code"
531
876
  }
@@ -538,6 +883,8 @@ export declare type AgreementClassUpdatedEvent = Event & {
538
883
  /** Empty addresses array. */
539
884
  addresses: Array<Scalars['Bytes']>;
540
885
  blockNumber: Scalars['BigInt'];
886
+ logIndex: Scalars['BigInt'];
887
+ order: Scalars['BigInt'];
541
888
  agreementType: Scalars['Bytes'];
542
889
  code: Scalars['Bytes'];
543
890
  };
@@ -598,6 +945,22 @@ export declare type AgreementClassUpdatedEvent_Filter = {
598
945
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
599
946
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
600
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']>>;
601
964
  agreementType?: Maybe<Scalars['Bytes']>;
602
965
  agreementType_not?: Maybe<Scalars['Bytes']>;
603
966
  agreementType_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -620,6 +983,8 @@ export declare enum AgreementClassUpdatedEvent_OrderBy {
620
983
  Name = "name",
621
984
  Addresses = "addresses",
622
985
  BlockNumber = "blockNumber",
986
+ LogIndex = "logIndex",
987
+ Order = "order",
623
988
  AgreementType = "agreementType",
624
989
  Code = "code"
625
990
  }
@@ -632,6 +997,8 @@ export declare type AgreementLiquidatedByEvent = Event & {
632
997
  /** Holds the token, liquidatorAccount, penaltyAccount and bondAccount addresses. */
633
998
  addresses: Array<Scalars['Bytes']>;
634
999
  blockNumber: Scalars['BigInt'];
1000
+ logIndex: Scalars['BigInt'];
1001
+ order: Scalars['BigInt'];
635
1002
  token: Scalars['Bytes'];
636
1003
  liquidatorAccount: Scalars['Bytes'];
637
1004
  agreementClass: Scalars['Bytes'];
@@ -698,6 +1065,22 @@ export declare type AgreementLiquidatedByEvent_Filter = {
698
1065
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
699
1066
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
700
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']>>;
701
1084
  token?: Maybe<Scalars['Bytes']>;
702
1085
  token_not?: Maybe<Scalars['Bytes']>;
703
1086
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -760,6 +1143,8 @@ export declare enum AgreementLiquidatedByEvent_OrderBy {
760
1143
  Name = "name",
761
1144
  Addresses = "addresses",
762
1145
  BlockNumber = "blockNumber",
1146
+ LogIndex = "logIndex",
1147
+ Order = "order",
763
1148
  Token = "token",
764
1149
  LiquidatorAccount = "liquidatorAccount",
765
1150
  AgreementClass = "agreementClass",
@@ -778,6 +1163,8 @@ export declare type AgreementLiquidatedV2Event = Event & {
778
1163
  /** Holds the token, liquidatorAccount, targetAccount and rewardAccount addresses. */
779
1164
  addresses: Array<Scalars['Bytes']>;
780
1165
  blockNumber: Scalars['BigInt'];
1166
+ logIndex: Scalars['BigInt'];
1167
+ order: Scalars['BigInt'];
781
1168
  token: Scalars['Bytes'];
782
1169
  liquidatorAccount: Scalars['Bytes'];
783
1170
  agreementClass: Scalars['Bytes'];
@@ -846,6 +1233,22 @@ export declare type AgreementLiquidatedV2Event_Filter = {
846
1233
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
847
1234
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
848
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']>>;
849
1252
  token?: Maybe<Scalars['Bytes']>;
850
1253
  token_not?: Maybe<Scalars['Bytes']>;
851
1254
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -924,6 +1327,8 @@ export declare enum AgreementLiquidatedV2Event_OrderBy {
924
1327
  Name = "name",
925
1328
  Addresses = "addresses",
926
1329
  BlockNumber = "blockNumber",
1330
+ LogIndex = "logIndex",
1331
+ Order = "order",
927
1332
  Token = "token",
928
1333
  LiquidatorAccount = "liquidatorAccount",
929
1334
  AgreementClass = "agreementClass",
@@ -944,6 +1349,8 @@ export declare type AppRegisteredEvent = Event & {
944
1349
  /** Empty addresses array. */
945
1350
  addresses: Array<Scalars['Bytes']>;
946
1351
  blockNumber: Scalars['BigInt'];
1352
+ logIndex: Scalars['BigInt'];
1353
+ order: Scalars['BigInt'];
947
1354
  app: Scalars['Bytes'];
948
1355
  };
949
1356
  export declare type AppRegisteredEvent_Filter = {
@@ -1003,6 +1410,22 @@ export declare type AppRegisteredEvent_Filter = {
1003
1410
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1004
1411
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1005
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']>>;
1006
1429
  app?: Maybe<Scalars['Bytes']>;
1007
1430
  app_not?: Maybe<Scalars['Bytes']>;
1008
1431
  app_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1019,6 +1442,8 @@ export declare enum AppRegisteredEvent_OrderBy {
1019
1442
  Name = "name",
1020
1443
  Addresses = "addresses",
1021
1444
  BlockNumber = "blockNumber",
1445
+ LogIndex = "logIndex",
1446
+ Order = "order",
1022
1447
  App = "app"
1023
1448
  }
1024
1449
  export declare type BlockChangedFilter = {
@@ -1038,6 +1463,8 @@ export declare type BurnedEvent = Event & {
1038
1463
  /** Holds the token and from addresses. */
1039
1464
  addresses: Array<Scalars['Bytes']>;
1040
1465
  blockNumber: Scalars['BigInt'];
1466
+ logIndex: Scalars['BigInt'];
1467
+ order: Scalars['BigInt'];
1041
1468
  operator: Scalars['Bytes'];
1042
1469
  from: Scalars['Bytes'];
1043
1470
  amount: Scalars['BigInt'];
@@ -1101,6 +1528,22 @@ export declare type BurnedEvent_Filter = {
1101
1528
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1102
1529
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1103
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']>>;
1104
1547
  operator?: Maybe<Scalars['Bytes']>;
1105
1548
  operator_not?: Maybe<Scalars['Bytes']>;
1106
1549
  operator_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1143,6 +1586,8 @@ export declare enum BurnedEvent_OrderBy {
1143
1586
  Name = "name",
1144
1587
  Addresses = "addresses",
1145
1588
  BlockNumber = "blockNumber",
1589
+ LogIndex = "logIndex",
1590
+ Order = "order",
1146
1591
  Operator = "operator",
1147
1592
  From = "from",
1148
1593
  Amount = "amount",
@@ -1158,6 +1603,8 @@ export declare type CfAv1LiquidationPeriodChangedEvent = Event & {
1158
1603
  /** Empty addresses array. */
1159
1604
  addresses: Array<Scalars['Bytes']>;
1160
1605
  blockNumber: Scalars['BigInt'];
1606
+ order: Scalars['BigInt'];
1607
+ logIndex: Scalars['BigInt'];
1161
1608
  host: Scalars['Bytes'];
1162
1609
  superToken: Scalars['Bytes'];
1163
1610
  isKeySet: Scalars['Boolean'];
@@ -1220,6 +1667,22 @@ export declare type CfAv1LiquidationPeriodChangedEvent_Filter = {
1220
1667
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1221
1668
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1222
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']>>;
1223
1686
  host?: Maybe<Scalars['Bytes']>;
1224
1687
  host_not?: Maybe<Scalars['Bytes']>;
1225
1688
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1254,6 +1717,8 @@ export declare enum CfAv1LiquidationPeriodChangedEvent_OrderBy {
1254
1717
  Name = "name",
1255
1718
  Addresses = "addresses",
1256
1719
  BlockNumber = "blockNumber",
1720
+ Order = "order",
1721
+ LogIndex = "logIndex",
1257
1722
  Host = "host",
1258
1723
  SuperToken = "superToken",
1259
1724
  IsKeySet = "isKeySet",
@@ -1268,6 +1733,8 @@ export declare type ConfigChangedEvent = Event & {
1268
1733
  /** Empty addresses array. */
1269
1734
  addresses: Array<Scalars['Bytes']>;
1270
1735
  blockNumber: Scalars['BigInt'];
1736
+ logIndex: Scalars['BigInt'];
1737
+ order: Scalars['BigInt'];
1271
1738
  host: Scalars['Bytes'];
1272
1739
  superToken: Scalars['Bytes'];
1273
1740
  key: Scalars['Bytes'];
@@ -1331,6 +1798,22 @@ export declare type ConfigChangedEvent_Filter = {
1331
1798
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1332
1799
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1333
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']>>;
1334
1817
  host?: Maybe<Scalars['Bytes']>;
1335
1818
  host_not?: Maybe<Scalars['Bytes']>;
1336
1819
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1371,6 +1854,8 @@ export declare enum ConfigChangedEvent_OrderBy {
1371
1854
  Name = "name",
1372
1855
  Addresses = "addresses",
1373
1856
  BlockNumber = "blockNumber",
1857
+ LogIndex = "logIndex",
1858
+ Order = "order",
1374
1859
  Host = "host",
1375
1860
  SuperToken = "superToken",
1376
1861
  Key = "key",
@@ -1386,6 +1871,8 @@ export declare type CustomSuperTokenCreatedEvent = Event & {
1386
1871
  /** Holds the token address. */
1387
1872
  addresses: Array<Scalars['Bytes']>;
1388
1873
  blockNumber: Scalars['BigInt'];
1874
+ logIndex: Scalars['BigInt'];
1875
+ order: Scalars['BigInt'];
1389
1876
  token: Scalars['Bytes'];
1390
1877
  };
1391
1878
  export declare type CustomSuperTokenCreatedEvent_Filter = {
@@ -1445,6 +1932,22 @@ export declare type CustomSuperTokenCreatedEvent_Filter = {
1445
1932
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1446
1933
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1447
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']>>;
1448
1951
  token?: Maybe<Scalars['Bytes']>;
1449
1952
  token_not?: Maybe<Scalars['Bytes']>;
1450
1953
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1461,6 +1964,8 @@ export declare enum CustomSuperTokenCreatedEvent_OrderBy {
1461
1964
  Name = "name",
1462
1965
  Addresses = "addresses",
1463
1966
  BlockNumber = "blockNumber",
1967
+ LogIndex = "logIndex",
1968
+ Order = "order",
1464
1969
  Token = "token"
1465
1970
  }
1466
1971
  /**
@@ -1471,6 +1976,8 @@ export declare enum CustomSuperTokenCreatedEvent_OrderBy {
1471
1976
  export declare type Event = {
1472
1977
  id: Scalars['ID'];
1473
1978
  blockNumber: Scalars['BigInt'];
1979
+ logIndex: Scalars['BigInt'];
1980
+ order: Scalars['BigInt'];
1474
1981
  name: Scalars['String'];
1475
1982
  /** Holds the addresses for accounts that were impacted by the event. */
1476
1983
  addresses: Array<Scalars['Bytes']>;
@@ -1494,6 +2001,22 @@ export declare type Event_Filter = {
1494
2001
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1495
2002
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1496
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']>>;
1497
2020
  name?: Maybe<Scalars['String']>;
1498
2021
  name_not?: Maybe<Scalars['String']>;
1499
2022
  name_gt?: Maybe<Scalars['String']>;
@@ -1540,6 +2063,8 @@ export declare type Event_Filter = {
1540
2063
  export declare enum Event_OrderBy {
1541
2064
  Id = "id",
1542
2065
  BlockNumber = "blockNumber",
2066
+ LogIndex = "logIndex",
2067
+ Order = "order",
1543
2068
  Name = "name",
1544
2069
  Addresses = "addresses",
1545
2070
  Timestamp = "timestamp",
@@ -1596,6 +2121,8 @@ export declare type FlowOperatorUpdatedEvent = Event & {
1596
2121
  /** Holds the token, sender, and flowOperator addresses. */
1597
2122
  addresses: Array<Scalars['Bytes']>;
1598
2123
  blockNumber: Scalars['BigInt'];
2124
+ logIndex: Scalars['BigInt'];
2125
+ order: Scalars['BigInt'];
1599
2126
  /** The address of the `token` being streamed. */
1600
2127
  token: Scalars['Bytes'];
1601
2128
  sender: Scalars['Bytes'];
@@ -1664,6 +2191,22 @@ export declare type FlowOperatorUpdatedEvent_Filter = {
1664
2191
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1665
2192
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1666
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']>>;
1667
2210
  token?: Maybe<Scalars['Bytes']>;
1668
2211
  token_not?: Maybe<Scalars['Bytes']>;
1669
2212
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -1722,6 +2265,8 @@ export declare enum FlowOperatorUpdatedEvent_OrderBy {
1722
2265
  Name = "name",
1723
2266
  Addresses = "addresses",
1724
2267
  BlockNumber = "blockNumber",
2268
+ LogIndex = "logIndex",
2269
+ Order = "order",
1725
2270
  Token = "token",
1726
2271
  Sender = "sender",
1727
2272
  Permissions = "permissions",
@@ -1890,6 +2435,8 @@ export declare type FlowUpdatedEvent = Event & {
1890
2435
  /** Holds the token, sender and receiver addresses. */
1891
2436
  addresses: Array<Scalars['Bytes']>;
1892
2437
  blockNumber: Scalars['BigInt'];
2438
+ logIndex: Scalars['BigInt'];
2439
+ order: Scalars['BigInt'];
1893
2440
  /** The address of the `token` being streamed. */
1894
2441
  token: Scalars['Bytes'];
1895
2442
  sender: Scalars['Bytes'];
@@ -1980,6 +2527,22 @@ export declare type FlowUpdatedEvent_Filter = {
1980
2527
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
1981
2528
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
1982
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']>>;
1983
2546
  token?: Maybe<Scalars['Bytes']>;
1984
2547
  token_not?: Maybe<Scalars['Bytes']>;
1985
2548
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2096,6 +2659,8 @@ export declare enum FlowUpdatedEvent_OrderBy {
2096
2659
  Name = "name",
2097
2660
  Addresses = "addresses",
2098
2661
  BlockNumber = "blockNumber",
2662
+ LogIndex = "logIndex",
2663
+ Order = "order",
2099
2664
  Token = "token",
2100
2665
  Sender = "sender",
2101
2666
  Receiver = "receiver",
@@ -2118,6 +2683,8 @@ export declare type GovernanceReplacedEvent = Event & {
2118
2683
  name: Scalars['String'];
2119
2684
  addresses: Array<Scalars['Bytes']>;
2120
2685
  blockNumber: Scalars['BigInt'];
2686
+ logIndex: Scalars['BigInt'];
2687
+ order: Scalars['BigInt'];
2121
2688
  /** Empty addresses array. */
2122
2689
  oldGovernance: Scalars['Bytes'];
2123
2690
  newGovernance: Scalars['Bytes'];
@@ -2179,6 +2746,22 @@ export declare type GovernanceReplacedEvent_Filter = {
2179
2746
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2180
2747
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2181
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']>>;
2182
2765
  oldGovernance?: Maybe<Scalars['Bytes']>;
2183
2766
  oldGovernance_not?: Maybe<Scalars['Bytes']>;
2184
2767
  oldGovernance_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2201,6 +2784,8 @@ export declare enum GovernanceReplacedEvent_OrderBy {
2201
2784
  Name = "name",
2202
2785
  Addresses = "addresses",
2203
2786
  BlockNumber = "blockNumber",
2787
+ LogIndex = "logIndex",
2788
+ Order = "order",
2204
2789
  OldGovernance = "oldGovernance",
2205
2790
  NewGovernance = "newGovernance"
2206
2791
  }
@@ -2306,6 +2891,8 @@ export declare type IndexCreatedEvent = Event & {
2306
2891
  /** Holds the token and publisher addresses. */
2307
2892
  addresses: Array<Scalars['Bytes']>;
2308
2893
  blockNumber: Scalars['BigInt'];
2894
+ logIndex: Scalars['BigInt'];
2895
+ order: Scalars['BigInt'];
2309
2896
  token: Scalars['Bytes'];
2310
2897
  publisher: Scalars['Bytes'];
2311
2898
  indexId: Scalars['BigInt'];
@@ -2369,6 +2956,22 @@ export declare type IndexCreatedEvent_Filter = {
2369
2956
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2370
2957
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2371
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']>>;
2372
2975
  token?: Maybe<Scalars['Bytes']>;
2373
2976
  token_not?: Maybe<Scalars['Bytes']>;
2374
2977
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2425,6 +3028,8 @@ export declare enum IndexCreatedEvent_OrderBy {
2425
3028
  Name = "name",
2426
3029
  Addresses = "addresses",
2427
3030
  BlockNumber = "blockNumber",
3031
+ LogIndex = "logIndex",
3032
+ Order = "order",
2428
3033
  Token = "token",
2429
3034
  Publisher = "publisher",
2430
3035
  IndexId = "indexId",
@@ -2440,6 +3045,8 @@ export declare type IndexDistributionClaimedEvent = Event & {
2440
3045
  /** Holds the token, publisher and subscriber addresses. */
2441
3046
  addresses: Array<Scalars['Bytes']>;
2442
3047
  blockNumber: Scalars['BigInt'];
3048
+ logIndex: Scalars['BigInt'];
3049
+ order: Scalars['BigInt'];
2443
3050
  token: Scalars['Bytes'];
2444
3051
  publisher: Scalars['Bytes'];
2445
3052
  indexId: Scalars['BigInt'];
@@ -2504,6 +3111,22 @@ export declare type IndexDistributionClaimedEvent_Filter = {
2504
3111
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2505
3112
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2506
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']>>;
2507
3130
  token?: Maybe<Scalars['Bytes']>;
2508
3131
  token_not?: Maybe<Scalars['Bytes']>;
2509
3132
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2568,6 +3191,8 @@ export declare enum IndexDistributionClaimedEvent_OrderBy {
2568
3191
  Name = "name",
2569
3192
  Addresses = "addresses",
2570
3193
  BlockNumber = "blockNumber",
3194
+ LogIndex = "logIndex",
3195
+ Order = "order",
2571
3196
  Token = "token",
2572
3197
  Publisher = "publisher",
2573
3198
  IndexId = "indexId",
@@ -2584,6 +3209,8 @@ export declare type IndexSubscribedEvent = Event & {
2584
3209
  /** Holds the token, publisher and subscriber addresses. */
2585
3210
  addresses: Array<Scalars['Bytes']>;
2586
3211
  blockNumber: Scalars['BigInt'];
3212
+ logIndex: Scalars['BigInt'];
3213
+ order: Scalars['BigInt'];
2587
3214
  token: Scalars['Bytes'];
2588
3215
  publisher: Scalars['Bytes'];
2589
3216
  indexId: Scalars['BigInt'];
@@ -2648,6 +3275,22 @@ export declare type IndexSubscribedEvent_Filter = {
2648
3275
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
2649
3276
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2650
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']>>;
2651
3294
  token?: Maybe<Scalars['Bytes']>;
2652
3295
  token_not?: Maybe<Scalars['Bytes']>;
2653
3296
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -2710,6 +3353,8 @@ export declare enum IndexSubscribedEvent_OrderBy {
2710
3353
  Name = "name",
2711
3354
  Addresses = "addresses",
2712
3355
  BlockNumber = "blockNumber",
3356
+ LogIndex = "logIndex",
3357
+ Order = "order",
2713
3358
  Token = "token",
2714
3359
  Publisher = "publisher",
2715
3360
  IndexId = "indexId",
@@ -2940,6 +3585,8 @@ export declare type IndexUnitsUpdatedEvent = Event & {
2940
3585
  /** Holds the token, publisher and subscriber addresses. */
2941
3586
  addresses: Array<Scalars['Bytes']>;
2942
3587
  blockNumber: Scalars['BigInt'];
3588
+ logIndex: Scalars['BigInt'];
3589
+ order: Scalars['BigInt'];
2943
3590
  token: Scalars['Bytes'];
2944
3591
  publisher: Scalars['Bytes'];
2945
3592
  indexId: Scalars['BigInt'];
@@ -3006,6 +3653,22 @@ export declare type IndexUnitsUpdatedEvent_Filter = {
3006
3653
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3007
3654
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3008
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']>>;
3009
3672
  token?: Maybe<Scalars['Bytes']>;
3010
3673
  token_not?: Maybe<Scalars['Bytes']>;
3011
3674
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3084,6 +3747,8 @@ export declare enum IndexUnitsUpdatedEvent_OrderBy {
3084
3747
  Name = "name",
3085
3748
  Addresses = "addresses",
3086
3749
  BlockNumber = "blockNumber",
3750
+ LogIndex = "logIndex",
3751
+ Order = "order",
3087
3752
  Token = "token",
3088
3753
  Publisher = "publisher",
3089
3754
  IndexId = "indexId",
@@ -3102,6 +3767,8 @@ export declare type IndexUnsubscribedEvent = Event & {
3102
3767
  /** Holds the token, publisher and subscriber addresses. */
3103
3768
  addresses: Array<Scalars['Bytes']>;
3104
3769
  blockNumber: Scalars['BigInt'];
3770
+ logIndex: Scalars['BigInt'];
3771
+ order: Scalars['BigInt'];
3105
3772
  token: Scalars['Bytes'];
3106
3773
  publisher: Scalars['Bytes'];
3107
3774
  indexId: Scalars['BigInt'];
@@ -3166,6 +3833,22 @@ export declare type IndexUnsubscribedEvent_Filter = {
3166
3833
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3167
3834
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3168
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']>>;
3169
3852
  token?: Maybe<Scalars['Bytes']>;
3170
3853
  token_not?: Maybe<Scalars['Bytes']>;
3171
3854
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3228,6 +3911,8 @@ export declare enum IndexUnsubscribedEvent_OrderBy {
3228
3911
  Name = "name",
3229
3912
  Addresses = "addresses",
3230
3913
  BlockNumber = "blockNumber",
3914
+ LogIndex = "logIndex",
3915
+ Order = "order",
3231
3916
  Token = "token",
3232
3917
  Publisher = "publisher",
3233
3918
  IndexId = "indexId",
@@ -3244,6 +3929,8 @@ export declare type IndexUpdatedEvent = Event & {
3244
3929
  /** Holds the token and publisher addresses. */
3245
3930
  addresses: Array<Scalars['Bytes']>;
3246
3931
  blockNumber: Scalars['BigInt'];
3932
+ logIndex: Scalars['BigInt'];
3933
+ order: Scalars['BigInt'];
3247
3934
  token: Scalars['Bytes'];
3248
3935
  publisher: Scalars['Bytes'];
3249
3936
  indexId: Scalars['BigInt'];
@@ -3311,6 +3998,22 @@ export declare type IndexUpdatedEvent_Filter = {
3311
3998
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3312
3999
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3313
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']>>;
3314
4017
  token?: Maybe<Scalars['Bytes']>;
3315
4018
  token_not?: Maybe<Scalars['Bytes']>;
3316
4019
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3399,6 +4102,8 @@ export declare enum IndexUpdatedEvent_OrderBy {
3399
4102
  Name = "name",
3400
4103
  Addresses = "addresses",
3401
4104
  BlockNumber = "blockNumber",
4105
+ LogIndex = "logIndex",
4106
+ Order = "order",
3402
4107
  Token = "token",
3403
4108
  Publisher = "publisher",
3404
4109
  IndexId = "indexId",
@@ -3601,6 +4306,8 @@ export declare type JailEvent = Event & {
3601
4306
  /** Empty addresses array. */
3602
4307
  addresses: Array<Scalars['Bytes']>;
3603
4308
  blockNumber: Scalars['BigInt'];
4309
+ logIndex: Scalars['BigInt'];
4310
+ order: Scalars['BigInt'];
3604
4311
  app: Scalars['Bytes'];
3605
4312
  reason: Scalars['BigInt'];
3606
4313
  };
@@ -3661,6 +4368,22 @@ export declare type JailEvent_Filter = {
3661
4368
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3662
4369
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3663
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']>>;
3664
4387
  app?: Maybe<Scalars['Bytes']>;
3665
4388
  app_not?: Maybe<Scalars['Bytes']>;
3666
4389
  app_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3685,6 +4408,8 @@ export declare enum JailEvent_OrderBy {
3685
4408
  Name = "name",
3686
4409
  Addresses = "addresses",
3687
4410
  BlockNumber = "blockNumber",
4411
+ LogIndex = "logIndex",
4412
+ Order = "order",
3688
4413
  App = "app",
3689
4414
  Reason = "reason"
3690
4415
  }
@@ -3697,6 +4422,8 @@ export declare type MintedEvent = Event & {
3697
4422
  /** Holds the token, operator and to addresses. */
3698
4423
  addresses: Array<Scalars['Bytes']>;
3699
4424
  blockNumber: Scalars['BigInt'];
4425
+ logIndex: Scalars['BigInt'];
4426
+ order: Scalars['BigInt'];
3700
4427
  operator: Scalars['Bytes'];
3701
4428
  to: Scalars['Bytes'];
3702
4429
  amount: Scalars['BigInt'];
@@ -3760,6 +4487,22 @@ export declare type MintedEvent_Filter = {
3760
4487
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3761
4488
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3762
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']>>;
3763
4506
  operator?: Maybe<Scalars['Bytes']>;
3764
4507
  operator_not?: Maybe<Scalars['Bytes']>;
3765
4508
  operator_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3802,6 +4545,8 @@ export declare enum MintedEvent_OrderBy {
3802
4545
  Name = "name",
3803
4546
  Addresses = "addresses",
3804
4547
  BlockNumber = "blockNumber",
4548
+ LogIndex = "logIndex",
4549
+ Order = "order",
3805
4550
  Operator = "operator",
3806
4551
  To = "to",
3807
4552
  Amount = "amount",
@@ -3822,6 +4567,8 @@ export declare type PppConfigurationChangedEvent = Event & {
3822
4567
  /** Empty addresses array. */
3823
4568
  addresses: Array<Scalars['Bytes']>;
3824
4569
  blockNumber: Scalars['BigInt'];
4570
+ logIndex: Scalars['BigInt'];
4571
+ order: Scalars['BigInt'];
3825
4572
  host: Scalars['Bytes'];
3826
4573
  superToken: Scalars['Bytes'];
3827
4574
  isKeySet: Scalars['Boolean'];
@@ -3885,6 +4632,22 @@ export declare type PppConfigurationChangedEvent_Filter = {
3885
4632
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
3886
4633
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
3887
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']>>;
3888
4651
  host?: Maybe<Scalars['Bytes']>;
3889
4652
  host_not?: Maybe<Scalars['Bytes']>;
3890
4653
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -3927,6 +4690,8 @@ export declare enum PppConfigurationChangedEvent_OrderBy {
3927
4690
  Name = "name",
3928
4691
  Addresses = "addresses",
3929
4692
  BlockNumber = "blockNumber",
4693
+ LogIndex = "logIndex",
4694
+ Order = "order",
3930
4695
  Host = "host",
3931
4696
  SuperToken = "superToken",
3932
4697
  IsKeySet = "isKeySet",
@@ -4029,6 +4794,8 @@ export declare type Query = {
4029
4794
  tokens: Array<Token>;
4030
4795
  accountTokenSnapshot?: Maybe<AccountTokenSnapshot>;
4031
4796
  accountTokenSnapshots: Array<AccountTokenSnapshot>;
4797
+ accountTokenSnapshotLog?: Maybe<AccountTokenSnapshotLog>;
4798
+ accountTokenSnapshotLogs: Array<AccountTokenSnapshotLog>;
4032
4799
  tokenStatistic?: Maybe<TokenStatistic>;
4033
4800
  tokenStatistics: Array<TokenStatistic>;
4034
4801
  sfmeta?: Maybe<SfMeta>;
@@ -4696,6 +5463,20 @@ export declare type QueryAccountTokenSnapshotsArgs = {
4696
5463
  block?: Maybe<Block_Height>;
4697
5464
  subgraphError?: _SubgraphErrorPolicy_;
4698
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
+ };
4699
5480
  export declare type QueryTokenStatisticArgs = {
4700
5481
  id: Scalars['ID'];
4701
5482
  block?: Maybe<Block_Height>;
@@ -4750,6 +5531,8 @@ export declare type RewardAddressChangedEvent = Event & {
4750
5531
  /** Empty addresses array. */
4751
5532
  addresses: Array<Scalars['Bytes']>;
4752
5533
  blockNumber: Scalars['BigInt'];
5534
+ logIndex: Scalars['BigInt'];
5535
+ order: Scalars['BigInt'];
4753
5536
  host: Scalars['Bytes'];
4754
5537
  superToken: Scalars['Bytes'];
4755
5538
  isKeySet: Scalars['Boolean'];
@@ -4812,6 +5595,22 @@ export declare type RewardAddressChangedEvent_Filter = {
4812
5595
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4813
5596
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4814
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']>>;
4815
5614
  host?: Maybe<Scalars['Bytes']>;
4816
5615
  host_not?: Maybe<Scalars['Bytes']>;
4817
5616
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4844,6 +5643,8 @@ export declare enum RewardAddressChangedEvent_OrderBy {
4844
5643
  Name = "name",
4845
5644
  Addresses = "addresses",
4846
5645
  BlockNumber = "blockNumber",
5646
+ LogIndex = "logIndex",
5647
+ Order = "order",
4847
5648
  Host = "host",
4848
5649
  SuperToken = "superToken",
4849
5650
  IsKeySet = "isKeySet",
@@ -4858,6 +5659,8 @@ export declare type RoleAdminChangedEvent = Event & {
4858
5659
  /** Empty addresses array. */
4859
5660
  addresses: Array<Scalars['Bytes']>;
4860
5661
  blockNumber: Scalars['BigInt'];
5662
+ logIndex: Scalars['BigInt'];
5663
+ order: Scalars['BigInt'];
4861
5664
  role: Scalars['Bytes'];
4862
5665
  previousAdminRole: Scalars['Bytes'];
4863
5666
  newAdminRole: Scalars['Bytes'];
@@ -4919,6 +5722,22 @@ export declare type RoleAdminChangedEvent_Filter = {
4919
5722
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
4920
5723
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
4921
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']>>;
4922
5741
  role?: Maybe<Scalars['Bytes']>;
4923
5742
  role_not?: Maybe<Scalars['Bytes']>;
4924
5743
  role_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -4947,6 +5766,8 @@ export declare enum RoleAdminChangedEvent_OrderBy {
4947
5766
  Name = "name",
4948
5767
  Addresses = "addresses",
4949
5768
  BlockNumber = "blockNumber",
5769
+ LogIndex = "logIndex",
5770
+ Order = "order",
4950
5771
  Role = "role",
4951
5772
  PreviousAdminRole = "previousAdminRole",
4952
5773
  NewAdminRole = "newAdminRole"
@@ -4960,6 +5781,8 @@ export declare type RoleGrantedEvent = Event & {
4960
5781
  /** Empty addresses array. */
4961
5782
  addresses: Array<Scalars['Bytes']>;
4962
5783
  blockNumber: Scalars['BigInt'];
5784
+ logIndex: Scalars['BigInt'];
5785
+ order: Scalars['BigInt'];
4963
5786
  role: Scalars['Bytes'];
4964
5787
  account: Scalars['Bytes'];
4965
5788
  sender: Scalars['Bytes'];
@@ -5021,6 +5844,22 @@ export declare type RoleGrantedEvent_Filter = {
5021
5844
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
5022
5845
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
5023
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']>>;
5024
5863
  role?: Maybe<Scalars['Bytes']>;
5025
5864
  role_not?: Maybe<Scalars['Bytes']>;
5026
5865
  role_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -5049,6 +5888,8 @@ export declare enum RoleGrantedEvent_OrderBy {
5049
5888
  Name = "name",
5050
5889
  Addresses = "addresses",
5051
5890
  BlockNumber = "blockNumber",
5891
+ LogIndex = "logIndex",
5892
+ Order = "order",
5052
5893
  Role = "role",
5053
5894
  Account = "account",
5054
5895
  Sender = "sender"
@@ -5062,6 +5903,8 @@ export declare type RoleRevokedEvent = Event & {
5062
5903
  /** Empty addresses array. */
5063
5904
  addresses: Array<Scalars['Bytes']>;
5064
5905
  blockNumber: Scalars['BigInt'];
5906
+ logIndex: Scalars['BigInt'];
5907
+ order: Scalars['BigInt'];
5065
5908
  role: Scalars['Bytes'];
5066
5909
  account: Scalars['Bytes'];
5067
5910
  sender: Scalars['Bytes'];
@@ -5123,6 +5966,22 @@ export declare type RoleRevokedEvent_Filter = {
5123
5966
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
5124
5967
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
5125
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']>>;
5126
5985
  role?: Maybe<Scalars['Bytes']>;
5127
5986
  role_not?: Maybe<Scalars['Bytes']>;
5128
5987
  role_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -5151,6 +6010,8 @@ export declare enum RoleRevokedEvent_OrderBy {
5151
6010
  Name = "name",
5152
6011
  Addresses = "addresses",
5153
6012
  BlockNumber = "blockNumber",
6013
+ LogIndex = "logIndex",
6014
+ Order = "order",
5154
6015
  Role = "role",
5155
6016
  Account = "account",
5156
6017
  Sender = "sender"
@@ -5250,6 +6111,8 @@ export declare type SentEvent = Event & {
5250
6111
  /** Holds the token, operator and from addresses. */
5251
6112
  addresses: Array<Scalars['Bytes']>;
5252
6113
  blockNumber: Scalars['BigInt'];
6114
+ logIndex: Scalars['BigInt'];
6115
+ order: Scalars['BigInt'];
5253
6116
  operator: Scalars['Bytes'];
5254
6117
  from: Scalars['Bytes'];
5255
6118
  to: Scalars['Bytes'];
@@ -5314,6 +6177,22 @@ export declare type SentEvent_Filter = {
5314
6177
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
5315
6178
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
5316
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']>>;
5317
6196
  operator?: Maybe<Scalars['Bytes']>;
5318
6197
  operator_not?: Maybe<Scalars['Bytes']>;
5319
6198
  operator_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -5362,6 +6241,8 @@ export declare enum SentEvent_OrderBy {
5362
6241
  Name = "name",
5363
6242
  Addresses = "addresses",
5364
6243
  BlockNumber = "blockNumber",
6244
+ LogIndex = "logIndex",
6245
+ Order = "order",
5365
6246
  Operator = "operator",
5366
6247
  From = "from",
5367
6248
  To = "to",
@@ -5928,6 +6809,8 @@ export declare type Subscription = {
5928
6809
  tokens: Array<Token>;
5929
6810
  accountTokenSnapshot?: Maybe<AccountTokenSnapshot>;
5930
6811
  accountTokenSnapshots: Array<AccountTokenSnapshot>;
6812
+ accountTokenSnapshotLog?: Maybe<AccountTokenSnapshotLog>;
6813
+ accountTokenSnapshotLogs: Array<AccountTokenSnapshotLog>;
5931
6814
  tokenStatistic?: Maybe<TokenStatistic>;
5932
6815
  tokenStatistics: Array<TokenStatistic>;
5933
6816
  sfmeta?: Maybe<SfMeta>;
@@ -6595,6 +7478,20 @@ export declare type SubscriptionAccountTokenSnapshotsArgs = {
6595
7478
  block?: Maybe<Block_Height>;
6596
7479
  subgraphError?: _SubgraphErrorPolicy_;
6597
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
+ };
6598
7495
  export declare type SubscriptionTokenStatisticArgs = {
6599
7496
  id: Scalars['ID'];
6600
7497
  block?: Maybe<Block_Height>;
@@ -6649,6 +7546,8 @@ export declare type SubscriptionApprovedEvent = Event & {
6649
7546
  /** Holds the token, publisher and subscriber addresses. */
6650
7547
  addresses: Array<Scalars['Bytes']>;
6651
7548
  blockNumber: Scalars['BigInt'];
7549
+ logIndex: Scalars['BigInt'];
7550
+ order: Scalars['BigInt'];
6652
7551
  token: Scalars['Bytes'];
6653
7552
  subscriber: Scalars['Bytes'];
6654
7553
  publisher: Scalars['Bytes'];
@@ -6713,6 +7612,22 @@ export declare type SubscriptionApprovedEvent_Filter = {
6713
7612
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6714
7613
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6715
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']>>;
6716
7631
  token?: Maybe<Scalars['Bytes']>;
6717
7632
  token_not?: Maybe<Scalars['Bytes']>;
6718
7633
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6775,6 +7690,8 @@ export declare enum SubscriptionApprovedEvent_OrderBy {
6775
7690
  Name = "name",
6776
7691
  Addresses = "addresses",
6777
7692
  BlockNumber = "blockNumber",
7693
+ LogIndex = "logIndex",
7694
+ Order = "order",
6778
7695
  Token = "token",
6779
7696
  Subscriber = "subscriber",
6780
7697
  Publisher = "publisher",
@@ -6791,6 +7708,8 @@ export declare type SubscriptionDistributionClaimedEvent = Event & {
6791
7708
  /** Holds the token, publisher and subscriber addresses. */
6792
7709
  addresses: Array<Scalars['Bytes']>;
6793
7710
  blockNumber: Scalars['BigInt'];
7711
+ logIndex: Scalars['BigInt'];
7712
+ order: Scalars['BigInt'];
6794
7713
  token: Scalars['Bytes'];
6795
7714
  subscriber: Scalars['Bytes'];
6796
7715
  publisher: Scalars['Bytes'];
@@ -6855,6 +7774,22 @@ export declare type SubscriptionDistributionClaimedEvent_Filter = {
6855
7774
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
6856
7775
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
6857
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']>>;
6858
7793
  token?: Maybe<Scalars['Bytes']>;
6859
7794
  token_not?: Maybe<Scalars['Bytes']>;
6860
7795
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -6919,6 +7854,8 @@ export declare enum SubscriptionDistributionClaimedEvent_OrderBy {
6919
7854
  Name = "name",
6920
7855
  Addresses = "addresses",
6921
7856
  BlockNumber = "blockNumber",
7857
+ LogIndex = "logIndex",
7858
+ Order = "order",
6922
7859
  Token = "token",
6923
7860
  Subscriber = "subscriber",
6924
7861
  Publisher = "publisher",
@@ -6935,6 +7872,8 @@ export declare type SubscriptionRevokedEvent = Event & {
6935
7872
  /** Holds the token, publisher and subscriber addresses. */
6936
7873
  addresses: Array<Scalars['Bytes']>;
6937
7874
  blockNumber: Scalars['BigInt'];
7875
+ logIndex: Scalars['BigInt'];
7876
+ order: Scalars['BigInt'];
6938
7877
  token: Scalars['Bytes'];
6939
7878
  subscriber: Scalars['Bytes'];
6940
7879
  publisher: Scalars['Bytes'];
@@ -6999,6 +7938,22 @@ export declare type SubscriptionRevokedEvent_Filter = {
6999
7938
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7000
7939
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7001
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']>>;
7002
7957
  token?: Maybe<Scalars['Bytes']>;
7003
7958
  token_not?: Maybe<Scalars['Bytes']>;
7004
7959
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7061,6 +8016,8 @@ export declare enum SubscriptionRevokedEvent_OrderBy {
7061
8016
  Name = "name",
7062
8017
  Addresses = "addresses",
7063
8018
  BlockNumber = "blockNumber",
8019
+ LogIndex = "logIndex",
8020
+ Order = "order",
7064
8021
  Token = "token",
7065
8022
  Subscriber = "subscriber",
7066
8023
  Publisher = "publisher",
@@ -7077,6 +8034,8 @@ export declare type SubscriptionUnitsUpdatedEvent = Event & {
7077
8034
  /** Holds the token, publisher and subscriber addresses. */
7078
8035
  addresses: Array<Scalars['Bytes']>;
7079
8036
  blockNumber: Scalars['BigInt'];
8037
+ logIndex: Scalars['BigInt'];
8038
+ order: Scalars['BigInt'];
7080
8039
  token: Scalars['Bytes'];
7081
8040
  subscriber: Scalars['Bytes'];
7082
8041
  publisher: Scalars['Bytes'];
@@ -7143,6 +8102,22 @@ export declare type SubscriptionUnitsUpdatedEvent_Filter = {
7143
8102
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7144
8103
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7145
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']>>;
7146
8121
  token?: Maybe<Scalars['Bytes']>;
7147
8122
  token_not?: Maybe<Scalars['Bytes']>;
7148
8123
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7221,6 +8196,8 @@ export declare enum SubscriptionUnitsUpdatedEvent_OrderBy {
7221
8196
  Name = "name",
7222
8197
  Addresses = "addresses",
7223
8198
  BlockNumber = "blockNumber",
8199
+ LogIndex = "logIndex",
8200
+ Order = "order",
7224
8201
  Token = "token",
7225
8202
  Subscriber = "subscriber",
7226
8203
  Publisher = "publisher",
@@ -7239,6 +8216,8 @@ export declare type SuperTokenCreatedEvent = Event & {
7239
8216
  /** Holds the token address. */
7240
8217
  addresses: Array<Scalars['Bytes']>;
7241
8218
  blockNumber: Scalars['BigInt'];
8219
+ logIndex: Scalars['BigInt'];
8220
+ order: Scalars['BigInt'];
7242
8221
  token: Scalars['Bytes'];
7243
8222
  };
7244
8223
  export declare type SuperTokenCreatedEvent_Filter = {
@@ -7298,6 +8277,22 @@ export declare type SuperTokenCreatedEvent_Filter = {
7298
8277
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7299
8278
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7300
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']>>;
7301
8296
  token?: Maybe<Scalars['Bytes']>;
7302
8297
  token_not?: Maybe<Scalars['Bytes']>;
7303
8298
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7314,6 +8309,8 @@ export declare enum SuperTokenCreatedEvent_OrderBy {
7314
8309
  Name = "name",
7315
8310
  Addresses = "addresses",
7316
8311
  BlockNumber = "blockNumber",
8312
+ LogIndex = "logIndex",
8313
+ Order = "order",
7317
8314
  Token = "token"
7318
8315
  }
7319
8316
  export declare type SuperTokenFactoryUpdatedEvent = Event & {
@@ -7325,6 +8322,8 @@ export declare type SuperTokenFactoryUpdatedEvent = Event & {
7325
8322
  /** Empty addresses array. */
7326
8323
  addresses: Array<Scalars['Bytes']>;
7327
8324
  blockNumber: Scalars['BigInt'];
8325
+ logIndex: Scalars['BigInt'];
8326
+ order: Scalars['BigInt'];
7328
8327
  newFactory: Scalars['Bytes'];
7329
8328
  };
7330
8329
  export declare type SuperTokenFactoryUpdatedEvent_Filter = {
@@ -7384,6 +8383,22 @@ export declare type SuperTokenFactoryUpdatedEvent_Filter = {
7384
8383
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7385
8384
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7386
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']>>;
7387
8402
  newFactory?: Maybe<Scalars['Bytes']>;
7388
8403
  newFactory_not?: Maybe<Scalars['Bytes']>;
7389
8404
  newFactory_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7400,6 +8415,8 @@ export declare enum SuperTokenFactoryUpdatedEvent_OrderBy {
7400
8415
  Name = "name",
7401
8416
  Addresses = "addresses",
7402
8417
  BlockNumber = "blockNumber",
8418
+ LogIndex = "logIndex",
8419
+ Order = "order",
7403
8420
  NewFactory = "newFactory"
7404
8421
  }
7405
8422
  export declare type SuperTokenLogicCreatedEvent = Event & {
@@ -7411,6 +8428,8 @@ export declare type SuperTokenLogicCreatedEvent = Event & {
7411
8428
  /** Empty addresses array. */
7412
8429
  addresses: Array<Scalars['Bytes']>;
7413
8430
  blockNumber: Scalars['BigInt'];
8431
+ logIndex: Scalars['BigInt'];
8432
+ order: Scalars['BigInt'];
7414
8433
  tokenLogic: Scalars['Bytes'];
7415
8434
  };
7416
8435
  export declare type SuperTokenLogicCreatedEvent_Filter = {
@@ -7470,6 +8489,22 @@ export declare type SuperTokenLogicCreatedEvent_Filter = {
7470
8489
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7471
8490
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7472
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']>>;
7473
8508
  tokenLogic?: Maybe<Scalars['Bytes']>;
7474
8509
  tokenLogic_not?: Maybe<Scalars['Bytes']>;
7475
8510
  tokenLogic_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7486,6 +8521,8 @@ export declare enum SuperTokenLogicCreatedEvent_OrderBy {
7486
8521
  Name = "name",
7487
8522
  Addresses = "addresses",
7488
8523
  BlockNumber = "blockNumber",
8524
+ LogIndex = "logIndex",
8525
+ Order = "order",
7489
8526
  TokenLogic = "tokenLogic"
7490
8527
  }
7491
8528
  export declare type SuperTokenLogicUpdatedEvent = Event & {
@@ -7497,6 +8534,8 @@ export declare type SuperTokenLogicUpdatedEvent = Event & {
7497
8534
  /** Empty addresses array. */
7498
8535
  addresses: Array<Scalars['Bytes']>;
7499
8536
  blockNumber: Scalars['BigInt'];
8537
+ logIndex: Scalars['BigInt'];
8538
+ order: Scalars['BigInt'];
7500
8539
  token: Scalars['Bytes'];
7501
8540
  code: Scalars['Bytes'];
7502
8541
  };
@@ -7557,6 +8596,22 @@ export declare type SuperTokenLogicUpdatedEvent_Filter = {
7557
8596
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7558
8597
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7559
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']>>;
7560
8615
  token?: Maybe<Scalars['Bytes']>;
7561
8616
  token_not?: Maybe<Scalars['Bytes']>;
7562
8617
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7579,6 +8634,8 @@ export declare enum SuperTokenLogicUpdatedEvent_OrderBy {
7579
8634
  Name = "name",
7580
8635
  Addresses = "addresses",
7581
8636
  BlockNumber = "blockNumber",
8637
+ LogIndex = "logIndex",
8638
+ Order = "order",
7582
8639
  Token = "token",
7583
8640
  Code = "code"
7584
8641
  }
@@ -7616,6 +8673,8 @@ export declare type TokenDowngradedEvent = Event & {
7616
8673
  /** Holds the token and account addresses. */
7617
8674
  addresses: Array<Scalars['Bytes']>;
7618
8675
  blockNumber: Scalars['BigInt'];
8676
+ logIndex: Scalars['BigInt'];
8677
+ order: Scalars['BigInt'];
7619
8678
  token: Scalars['Bytes'];
7620
8679
  amount: Scalars['BigInt'];
7621
8680
  };
@@ -7696,6 +8755,22 @@ export declare type TokenDowngradedEvent_Filter = {
7696
8755
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
7697
8756
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
7698
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']>>;
7699
8774
  token?: Maybe<Scalars['Bytes']>;
7700
8775
  token_not?: Maybe<Scalars['Bytes']>;
7701
8776
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -7721,6 +8796,8 @@ export declare enum TokenDowngradedEvent_OrderBy {
7721
8796
  Name = "name",
7722
8797
  Addresses = "addresses",
7723
8798
  BlockNumber = "blockNumber",
8799
+ LogIndex = "logIndex",
8800
+ Order = "order",
7724
8801
  Token = "token",
7725
8802
  Amount = "amount"
7726
8803
  }
@@ -7938,6 +9015,8 @@ export declare type TokenUpgradedEvent = Event & {
7938
9015
  /** Holds the token and account addresses. */
7939
9016
  addresses: Array<Scalars['Bytes']>;
7940
9017
  blockNumber: Scalars['BigInt'];
9018
+ logIndex: Scalars['BigInt'];
9019
+ order: Scalars['BigInt'];
7941
9020
  token: Scalars['Bytes'];
7942
9021
  amount: Scalars['BigInt'];
7943
9022
  };
@@ -8018,6 +9097,22 @@ export declare type TokenUpgradedEvent_Filter = {
8018
9097
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
8019
9098
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
8020
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']>>;
8021
9116
  token?: Maybe<Scalars['Bytes']>;
8022
9117
  token_not?: Maybe<Scalars['Bytes']>;
8023
9118
  token_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -8043,6 +9138,8 @@ export declare enum TokenUpgradedEvent_OrderBy {
8043
9138
  Name = "name",
8044
9139
  Addresses = "addresses",
8045
9140
  BlockNumber = "blockNumber",
9141
+ LogIndex = "logIndex",
9142
+ Order = "order",
8046
9143
  Token = "token",
8047
9144
  Amount = "amount"
8048
9145
  }
@@ -8177,6 +9274,8 @@ export declare type TransferEvent = Event & {
8177
9274
  /** Holds the token, from and to addresses. */
8178
9275
  addresses: Array<Scalars['Bytes']>;
8179
9276
  blockNumber: Scalars['BigInt'];
9277
+ logIndex: Scalars['BigInt'];
9278
+ order: Scalars['BigInt'];
8180
9279
  from: Account;
8181
9280
  to: Account;
8182
9281
  value: Scalars['BigInt'];
@@ -8239,6 +9338,22 @@ export declare type TransferEvent_Filter = {
8239
9338
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
8240
9339
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
8241
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']>>;
8242
9357
  from?: Maybe<Scalars['String']>;
8243
9358
  from_not?: Maybe<Scalars['String']>;
8244
9359
  from_gt?: Maybe<Scalars['String']>;
@@ -8303,6 +9418,8 @@ export declare enum TransferEvent_OrderBy {
8303
9418
  Name = "name",
8304
9419
  Addresses = "addresses",
8305
9420
  BlockNumber = "blockNumber",
9421
+ LogIndex = "logIndex",
9422
+ Order = "order",
8306
9423
  From = "from",
8307
9424
  To = "to",
8308
9425
  Value = "value",
@@ -8317,6 +9434,8 @@ export declare type TrustedForwarderChangedEvent = Event & {
8317
9434
  /** Empty addresses array. */
8318
9435
  addresses: Array<Scalars['Bytes']>;
8319
9436
  blockNumber: Scalars['BigInt'];
9437
+ logIndex: Scalars['BigInt'];
9438
+ order: Scalars['BigInt'];
8320
9439
  host: Scalars['Bytes'];
8321
9440
  superToken: Scalars['Bytes'];
8322
9441
  isKeySet: Scalars['Boolean'];
@@ -8380,6 +9499,22 @@ export declare type TrustedForwarderChangedEvent_Filter = {
8380
9499
  blockNumber_lte?: Maybe<Scalars['BigInt']>;
8381
9500
  blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
8382
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']>>;
8383
9518
  host?: Maybe<Scalars['Bytes']>;
8384
9519
  host_not?: Maybe<Scalars['Bytes']>;
8385
9520
  host_in?: Maybe<Array<Scalars['Bytes']>>;
@@ -8416,6 +9551,8 @@ export declare enum TrustedForwarderChangedEvent_OrderBy {
8416
9551
  Name = "name",
8417
9552
  Addresses = "addresses",
8418
9553
  BlockNumber = "blockNumber",
9554
+ LogIndex = "logIndex",
9555
+ Order = "order",
8419
9556
  Host = "host",
8420
9557
  SuperToken = "superToken",
8421
9558
  IsKeySet = "isKeySet",