@requestnetwork/payment-detection 0.38.1-next.1955 → 0.38.1-next.1957

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 +684 -9
  2. package/dist/thegraph/generated/graphql-superfluid.d.ts.map +1 -1
  3. package/dist/thegraph/generated/graphql-superfluid.js +79 -4
  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
@@ -2569,6 +2569,393 @@ export declare enum AppRegisteredEvent_OrderBy {
2569
2569
  Order = "order",
2570
2570
  App = "app"
2571
2571
  }
2572
+ export type ApprovalEvent = Event & {
2573
+ __typename?: 'ApprovalEvent';
2574
+ id: Scalars['ID'];
2575
+ transactionHash: Scalars['Bytes'];
2576
+ gasPrice: Scalars['BigInt'];
2577
+ gasUsed: Scalars['BigInt'];
2578
+ timestamp: Scalars['BigInt'];
2579
+ name: Scalars['String'];
2580
+ /** Empty addresses array. */
2581
+ addresses: Array<Scalars['Bytes']>;
2582
+ blockNumber: Scalars['BigInt'];
2583
+ logIndex: Scalars['BigInt'];
2584
+ order: Scalars['BigInt'];
2585
+ owner: Account;
2586
+ /** The address that will be granted allowance to transfer the NFT. */
2587
+ to: Account;
2588
+ /**
2589
+ * The id of the NFT that will be granted allowance to transfer.
2590
+ * The id is: uint256(keccak256(abi.encode(block.chainid, superToken, sender, receiver)))
2591
+ */
2592
+ tokenId: Scalars['BigInt'];
2593
+ };
2594
+ export type ApprovalEvent_Filter = {
2595
+ id?: Maybe<Scalars['ID']>;
2596
+ id_not?: Maybe<Scalars['ID']>;
2597
+ id_gt?: Maybe<Scalars['ID']>;
2598
+ id_lt?: Maybe<Scalars['ID']>;
2599
+ id_gte?: Maybe<Scalars['ID']>;
2600
+ id_lte?: Maybe<Scalars['ID']>;
2601
+ id_in?: Maybe<Array<Scalars['ID']>>;
2602
+ id_not_in?: Maybe<Array<Scalars['ID']>>;
2603
+ transactionHash?: Maybe<Scalars['Bytes']>;
2604
+ transactionHash_not?: Maybe<Scalars['Bytes']>;
2605
+ transactionHash_gt?: Maybe<Scalars['Bytes']>;
2606
+ transactionHash_lt?: Maybe<Scalars['Bytes']>;
2607
+ transactionHash_gte?: Maybe<Scalars['Bytes']>;
2608
+ transactionHash_lte?: Maybe<Scalars['Bytes']>;
2609
+ transactionHash_in?: Maybe<Array<Scalars['Bytes']>>;
2610
+ transactionHash_not_in?: Maybe<Array<Scalars['Bytes']>>;
2611
+ transactionHash_contains?: Maybe<Scalars['Bytes']>;
2612
+ transactionHash_not_contains?: Maybe<Scalars['Bytes']>;
2613
+ gasPrice?: Maybe<Scalars['BigInt']>;
2614
+ gasPrice_not?: Maybe<Scalars['BigInt']>;
2615
+ gasPrice_gt?: Maybe<Scalars['BigInt']>;
2616
+ gasPrice_lt?: Maybe<Scalars['BigInt']>;
2617
+ gasPrice_gte?: Maybe<Scalars['BigInt']>;
2618
+ gasPrice_lte?: Maybe<Scalars['BigInt']>;
2619
+ gasPrice_in?: Maybe<Array<Scalars['BigInt']>>;
2620
+ gasPrice_not_in?: Maybe<Array<Scalars['BigInt']>>;
2621
+ gasUsed?: Maybe<Scalars['BigInt']>;
2622
+ gasUsed_not?: Maybe<Scalars['BigInt']>;
2623
+ gasUsed_gt?: Maybe<Scalars['BigInt']>;
2624
+ gasUsed_lt?: Maybe<Scalars['BigInt']>;
2625
+ gasUsed_gte?: Maybe<Scalars['BigInt']>;
2626
+ gasUsed_lte?: Maybe<Scalars['BigInt']>;
2627
+ gasUsed_in?: Maybe<Array<Scalars['BigInt']>>;
2628
+ gasUsed_not_in?: Maybe<Array<Scalars['BigInt']>>;
2629
+ timestamp?: Maybe<Scalars['BigInt']>;
2630
+ timestamp_not?: Maybe<Scalars['BigInt']>;
2631
+ timestamp_gt?: Maybe<Scalars['BigInt']>;
2632
+ timestamp_lt?: Maybe<Scalars['BigInt']>;
2633
+ timestamp_gte?: Maybe<Scalars['BigInt']>;
2634
+ timestamp_lte?: Maybe<Scalars['BigInt']>;
2635
+ timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
2636
+ timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
2637
+ name?: Maybe<Scalars['String']>;
2638
+ name_not?: Maybe<Scalars['String']>;
2639
+ name_gt?: Maybe<Scalars['String']>;
2640
+ name_lt?: Maybe<Scalars['String']>;
2641
+ name_gte?: Maybe<Scalars['String']>;
2642
+ name_lte?: Maybe<Scalars['String']>;
2643
+ name_in?: Maybe<Array<Scalars['String']>>;
2644
+ name_not_in?: Maybe<Array<Scalars['String']>>;
2645
+ name_contains?: Maybe<Scalars['String']>;
2646
+ name_contains_nocase?: Maybe<Scalars['String']>;
2647
+ name_not_contains?: Maybe<Scalars['String']>;
2648
+ name_not_contains_nocase?: Maybe<Scalars['String']>;
2649
+ name_starts_with?: Maybe<Scalars['String']>;
2650
+ name_starts_with_nocase?: Maybe<Scalars['String']>;
2651
+ name_not_starts_with?: Maybe<Scalars['String']>;
2652
+ name_not_starts_with_nocase?: Maybe<Scalars['String']>;
2653
+ name_ends_with?: Maybe<Scalars['String']>;
2654
+ name_ends_with_nocase?: Maybe<Scalars['String']>;
2655
+ name_not_ends_with?: Maybe<Scalars['String']>;
2656
+ name_not_ends_with_nocase?: Maybe<Scalars['String']>;
2657
+ addresses?: Maybe<Array<Scalars['Bytes']>>;
2658
+ addresses_not?: Maybe<Array<Scalars['Bytes']>>;
2659
+ addresses_contains?: Maybe<Array<Scalars['Bytes']>>;
2660
+ addresses_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
2661
+ addresses_not_contains?: Maybe<Array<Scalars['Bytes']>>;
2662
+ addresses_not_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
2663
+ blockNumber?: Maybe<Scalars['BigInt']>;
2664
+ blockNumber_not?: Maybe<Scalars['BigInt']>;
2665
+ blockNumber_gt?: Maybe<Scalars['BigInt']>;
2666
+ blockNumber_lt?: Maybe<Scalars['BigInt']>;
2667
+ blockNumber_gte?: Maybe<Scalars['BigInt']>;
2668
+ blockNumber_lte?: Maybe<Scalars['BigInt']>;
2669
+ blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2670
+ blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2671
+ logIndex?: Maybe<Scalars['BigInt']>;
2672
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2673
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2674
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2675
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2676
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2677
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2678
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2679
+ order?: Maybe<Scalars['BigInt']>;
2680
+ order_not?: Maybe<Scalars['BigInt']>;
2681
+ order_gt?: Maybe<Scalars['BigInt']>;
2682
+ order_lt?: Maybe<Scalars['BigInt']>;
2683
+ order_gte?: Maybe<Scalars['BigInt']>;
2684
+ order_lte?: Maybe<Scalars['BigInt']>;
2685
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2686
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2687
+ owner?: Maybe<Scalars['String']>;
2688
+ owner_not?: Maybe<Scalars['String']>;
2689
+ owner_gt?: Maybe<Scalars['String']>;
2690
+ owner_lt?: Maybe<Scalars['String']>;
2691
+ owner_gte?: Maybe<Scalars['String']>;
2692
+ owner_lte?: Maybe<Scalars['String']>;
2693
+ owner_in?: Maybe<Array<Scalars['String']>>;
2694
+ owner_not_in?: Maybe<Array<Scalars['String']>>;
2695
+ owner_contains?: Maybe<Scalars['String']>;
2696
+ owner_contains_nocase?: Maybe<Scalars['String']>;
2697
+ owner_not_contains?: Maybe<Scalars['String']>;
2698
+ owner_not_contains_nocase?: Maybe<Scalars['String']>;
2699
+ owner_starts_with?: Maybe<Scalars['String']>;
2700
+ owner_starts_with_nocase?: Maybe<Scalars['String']>;
2701
+ owner_not_starts_with?: Maybe<Scalars['String']>;
2702
+ owner_not_starts_with_nocase?: Maybe<Scalars['String']>;
2703
+ owner_ends_with?: Maybe<Scalars['String']>;
2704
+ owner_ends_with_nocase?: Maybe<Scalars['String']>;
2705
+ owner_not_ends_with?: Maybe<Scalars['String']>;
2706
+ owner_not_ends_with_nocase?: Maybe<Scalars['String']>;
2707
+ owner_?: Maybe<Account_Filter>;
2708
+ to?: Maybe<Scalars['String']>;
2709
+ to_not?: Maybe<Scalars['String']>;
2710
+ to_gt?: Maybe<Scalars['String']>;
2711
+ to_lt?: Maybe<Scalars['String']>;
2712
+ to_gte?: Maybe<Scalars['String']>;
2713
+ to_lte?: Maybe<Scalars['String']>;
2714
+ to_in?: Maybe<Array<Scalars['String']>>;
2715
+ to_not_in?: Maybe<Array<Scalars['String']>>;
2716
+ to_contains?: Maybe<Scalars['String']>;
2717
+ to_contains_nocase?: Maybe<Scalars['String']>;
2718
+ to_not_contains?: Maybe<Scalars['String']>;
2719
+ to_not_contains_nocase?: Maybe<Scalars['String']>;
2720
+ to_starts_with?: Maybe<Scalars['String']>;
2721
+ to_starts_with_nocase?: Maybe<Scalars['String']>;
2722
+ to_not_starts_with?: Maybe<Scalars['String']>;
2723
+ to_not_starts_with_nocase?: Maybe<Scalars['String']>;
2724
+ to_ends_with?: Maybe<Scalars['String']>;
2725
+ to_ends_with_nocase?: Maybe<Scalars['String']>;
2726
+ to_not_ends_with?: Maybe<Scalars['String']>;
2727
+ to_not_ends_with_nocase?: Maybe<Scalars['String']>;
2728
+ to_?: Maybe<Account_Filter>;
2729
+ tokenId?: Maybe<Scalars['BigInt']>;
2730
+ tokenId_not?: Maybe<Scalars['BigInt']>;
2731
+ tokenId_gt?: Maybe<Scalars['BigInt']>;
2732
+ tokenId_lt?: Maybe<Scalars['BigInt']>;
2733
+ tokenId_gte?: Maybe<Scalars['BigInt']>;
2734
+ tokenId_lte?: Maybe<Scalars['BigInt']>;
2735
+ tokenId_in?: Maybe<Array<Scalars['BigInt']>>;
2736
+ tokenId_not_in?: Maybe<Array<Scalars['BigInt']>>;
2737
+ /** Filter for the block changed event. */
2738
+ _change_block?: Maybe<BlockChangedFilter>;
2739
+ and?: Maybe<Array<Maybe<ApprovalEvent_Filter>>>;
2740
+ or?: Maybe<Array<Maybe<ApprovalEvent_Filter>>>;
2741
+ };
2742
+ export declare enum ApprovalEvent_OrderBy {
2743
+ Id = "id",
2744
+ TransactionHash = "transactionHash",
2745
+ GasPrice = "gasPrice",
2746
+ GasUsed = "gasUsed",
2747
+ Timestamp = "timestamp",
2748
+ Name = "name",
2749
+ Addresses = "addresses",
2750
+ BlockNumber = "blockNumber",
2751
+ LogIndex = "logIndex",
2752
+ Order = "order",
2753
+ Owner = "owner",
2754
+ Owner__id = "owner__id",
2755
+ Owner__createdAtTimestamp = "owner__createdAtTimestamp",
2756
+ Owner__createdAtBlockNumber = "owner__createdAtBlockNumber",
2757
+ Owner__updatedAtTimestamp = "owner__updatedAtTimestamp",
2758
+ Owner__updatedAtBlockNumber = "owner__updatedAtBlockNumber",
2759
+ Owner__isSuperApp = "owner__isSuperApp",
2760
+ To = "to",
2761
+ To__id = "to__id",
2762
+ To__createdAtTimestamp = "to__createdAtTimestamp",
2763
+ To__createdAtBlockNumber = "to__createdAtBlockNumber",
2764
+ To__updatedAtTimestamp = "to__updatedAtTimestamp",
2765
+ To__updatedAtBlockNumber = "to__updatedAtBlockNumber",
2766
+ To__isSuperApp = "to__isSuperApp",
2767
+ TokenId = "tokenId"
2768
+ }
2769
+ export type ApprovalForAllEvent = Event & {
2770
+ __typename?: 'ApprovalForAllEvent';
2771
+ id: Scalars['ID'];
2772
+ transactionHash: Scalars['Bytes'];
2773
+ gasPrice: Scalars['BigInt'];
2774
+ gasUsed: Scalars['BigInt'];
2775
+ timestamp: Scalars['BigInt'];
2776
+ name: Scalars['String'];
2777
+ /** Empty addresses array. */
2778
+ addresses: Array<Scalars['Bytes']>;
2779
+ blockNumber: Scalars['BigInt'];
2780
+ logIndex: Scalars['BigInt'];
2781
+ order: Scalars['BigInt'];
2782
+ owner: Account;
2783
+ /** The address that will be granted operator permissions for the all of the owner's tokens. */
2784
+ operator: Account;
2785
+ /** Whether the operator is enabled or disabled for `owner`. */
2786
+ approved: Scalars['Boolean'];
2787
+ };
2788
+ export type ApprovalForAllEvent_Filter = {
2789
+ id?: Maybe<Scalars['ID']>;
2790
+ id_not?: Maybe<Scalars['ID']>;
2791
+ id_gt?: Maybe<Scalars['ID']>;
2792
+ id_lt?: Maybe<Scalars['ID']>;
2793
+ id_gte?: Maybe<Scalars['ID']>;
2794
+ id_lte?: Maybe<Scalars['ID']>;
2795
+ id_in?: Maybe<Array<Scalars['ID']>>;
2796
+ id_not_in?: Maybe<Array<Scalars['ID']>>;
2797
+ transactionHash?: Maybe<Scalars['Bytes']>;
2798
+ transactionHash_not?: Maybe<Scalars['Bytes']>;
2799
+ transactionHash_gt?: Maybe<Scalars['Bytes']>;
2800
+ transactionHash_lt?: Maybe<Scalars['Bytes']>;
2801
+ transactionHash_gte?: Maybe<Scalars['Bytes']>;
2802
+ transactionHash_lte?: Maybe<Scalars['Bytes']>;
2803
+ transactionHash_in?: Maybe<Array<Scalars['Bytes']>>;
2804
+ transactionHash_not_in?: Maybe<Array<Scalars['Bytes']>>;
2805
+ transactionHash_contains?: Maybe<Scalars['Bytes']>;
2806
+ transactionHash_not_contains?: Maybe<Scalars['Bytes']>;
2807
+ gasPrice?: Maybe<Scalars['BigInt']>;
2808
+ gasPrice_not?: Maybe<Scalars['BigInt']>;
2809
+ gasPrice_gt?: Maybe<Scalars['BigInt']>;
2810
+ gasPrice_lt?: Maybe<Scalars['BigInt']>;
2811
+ gasPrice_gte?: Maybe<Scalars['BigInt']>;
2812
+ gasPrice_lte?: Maybe<Scalars['BigInt']>;
2813
+ gasPrice_in?: Maybe<Array<Scalars['BigInt']>>;
2814
+ gasPrice_not_in?: Maybe<Array<Scalars['BigInt']>>;
2815
+ gasUsed?: Maybe<Scalars['BigInt']>;
2816
+ gasUsed_not?: Maybe<Scalars['BigInt']>;
2817
+ gasUsed_gt?: Maybe<Scalars['BigInt']>;
2818
+ gasUsed_lt?: Maybe<Scalars['BigInt']>;
2819
+ gasUsed_gte?: Maybe<Scalars['BigInt']>;
2820
+ gasUsed_lte?: Maybe<Scalars['BigInt']>;
2821
+ gasUsed_in?: Maybe<Array<Scalars['BigInt']>>;
2822
+ gasUsed_not_in?: Maybe<Array<Scalars['BigInt']>>;
2823
+ timestamp?: Maybe<Scalars['BigInt']>;
2824
+ timestamp_not?: Maybe<Scalars['BigInt']>;
2825
+ timestamp_gt?: Maybe<Scalars['BigInt']>;
2826
+ timestamp_lt?: Maybe<Scalars['BigInt']>;
2827
+ timestamp_gte?: Maybe<Scalars['BigInt']>;
2828
+ timestamp_lte?: Maybe<Scalars['BigInt']>;
2829
+ timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
2830
+ timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
2831
+ name?: Maybe<Scalars['String']>;
2832
+ name_not?: Maybe<Scalars['String']>;
2833
+ name_gt?: Maybe<Scalars['String']>;
2834
+ name_lt?: Maybe<Scalars['String']>;
2835
+ name_gte?: Maybe<Scalars['String']>;
2836
+ name_lte?: Maybe<Scalars['String']>;
2837
+ name_in?: Maybe<Array<Scalars['String']>>;
2838
+ name_not_in?: Maybe<Array<Scalars['String']>>;
2839
+ name_contains?: Maybe<Scalars['String']>;
2840
+ name_contains_nocase?: Maybe<Scalars['String']>;
2841
+ name_not_contains?: Maybe<Scalars['String']>;
2842
+ name_not_contains_nocase?: Maybe<Scalars['String']>;
2843
+ name_starts_with?: Maybe<Scalars['String']>;
2844
+ name_starts_with_nocase?: Maybe<Scalars['String']>;
2845
+ name_not_starts_with?: Maybe<Scalars['String']>;
2846
+ name_not_starts_with_nocase?: Maybe<Scalars['String']>;
2847
+ name_ends_with?: Maybe<Scalars['String']>;
2848
+ name_ends_with_nocase?: Maybe<Scalars['String']>;
2849
+ name_not_ends_with?: Maybe<Scalars['String']>;
2850
+ name_not_ends_with_nocase?: Maybe<Scalars['String']>;
2851
+ addresses?: Maybe<Array<Scalars['Bytes']>>;
2852
+ addresses_not?: Maybe<Array<Scalars['Bytes']>>;
2853
+ addresses_contains?: Maybe<Array<Scalars['Bytes']>>;
2854
+ addresses_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
2855
+ addresses_not_contains?: Maybe<Array<Scalars['Bytes']>>;
2856
+ addresses_not_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
2857
+ blockNumber?: Maybe<Scalars['BigInt']>;
2858
+ blockNumber_not?: Maybe<Scalars['BigInt']>;
2859
+ blockNumber_gt?: Maybe<Scalars['BigInt']>;
2860
+ blockNumber_lt?: Maybe<Scalars['BigInt']>;
2861
+ blockNumber_gte?: Maybe<Scalars['BigInt']>;
2862
+ blockNumber_lte?: Maybe<Scalars['BigInt']>;
2863
+ blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
2864
+ blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
2865
+ logIndex?: Maybe<Scalars['BigInt']>;
2866
+ logIndex_not?: Maybe<Scalars['BigInt']>;
2867
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
2868
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
2869
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
2870
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
2871
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
2872
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
2873
+ order?: Maybe<Scalars['BigInt']>;
2874
+ order_not?: Maybe<Scalars['BigInt']>;
2875
+ order_gt?: Maybe<Scalars['BigInt']>;
2876
+ order_lt?: Maybe<Scalars['BigInt']>;
2877
+ order_gte?: Maybe<Scalars['BigInt']>;
2878
+ order_lte?: Maybe<Scalars['BigInt']>;
2879
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
2880
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
2881
+ owner?: Maybe<Scalars['String']>;
2882
+ owner_not?: Maybe<Scalars['String']>;
2883
+ owner_gt?: Maybe<Scalars['String']>;
2884
+ owner_lt?: Maybe<Scalars['String']>;
2885
+ owner_gte?: Maybe<Scalars['String']>;
2886
+ owner_lte?: Maybe<Scalars['String']>;
2887
+ owner_in?: Maybe<Array<Scalars['String']>>;
2888
+ owner_not_in?: Maybe<Array<Scalars['String']>>;
2889
+ owner_contains?: Maybe<Scalars['String']>;
2890
+ owner_contains_nocase?: Maybe<Scalars['String']>;
2891
+ owner_not_contains?: Maybe<Scalars['String']>;
2892
+ owner_not_contains_nocase?: Maybe<Scalars['String']>;
2893
+ owner_starts_with?: Maybe<Scalars['String']>;
2894
+ owner_starts_with_nocase?: Maybe<Scalars['String']>;
2895
+ owner_not_starts_with?: Maybe<Scalars['String']>;
2896
+ owner_not_starts_with_nocase?: Maybe<Scalars['String']>;
2897
+ owner_ends_with?: Maybe<Scalars['String']>;
2898
+ owner_ends_with_nocase?: Maybe<Scalars['String']>;
2899
+ owner_not_ends_with?: Maybe<Scalars['String']>;
2900
+ owner_not_ends_with_nocase?: Maybe<Scalars['String']>;
2901
+ owner_?: Maybe<Account_Filter>;
2902
+ operator?: Maybe<Scalars['String']>;
2903
+ operator_not?: Maybe<Scalars['String']>;
2904
+ operator_gt?: Maybe<Scalars['String']>;
2905
+ operator_lt?: Maybe<Scalars['String']>;
2906
+ operator_gte?: Maybe<Scalars['String']>;
2907
+ operator_lte?: Maybe<Scalars['String']>;
2908
+ operator_in?: Maybe<Array<Scalars['String']>>;
2909
+ operator_not_in?: Maybe<Array<Scalars['String']>>;
2910
+ operator_contains?: Maybe<Scalars['String']>;
2911
+ operator_contains_nocase?: Maybe<Scalars['String']>;
2912
+ operator_not_contains?: Maybe<Scalars['String']>;
2913
+ operator_not_contains_nocase?: Maybe<Scalars['String']>;
2914
+ operator_starts_with?: Maybe<Scalars['String']>;
2915
+ operator_starts_with_nocase?: Maybe<Scalars['String']>;
2916
+ operator_not_starts_with?: Maybe<Scalars['String']>;
2917
+ operator_not_starts_with_nocase?: Maybe<Scalars['String']>;
2918
+ operator_ends_with?: Maybe<Scalars['String']>;
2919
+ operator_ends_with_nocase?: Maybe<Scalars['String']>;
2920
+ operator_not_ends_with?: Maybe<Scalars['String']>;
2921
+ operator_not_ends_with_nocase?: Maybe<Scalars['String']>;
2922
+ operator_?: Maybe<Account_Filter>;
2923
+ approved?: Maybe<Scalars['Boolean']>;
2924
+ approved_not?: Maybe<Scalars['Boolean']>;
2925
+ approved_in?: Maybe<Array<Scalars['Boolean']>>;
2926
+ approved_not_in?: Maybe<Array<Scalars['Boolean']>>;
2927
+ /** Filter for the block changed event. */
2928
+ _change_block?: Maybe<BlockChangedFilter>;
2929
+ and?: Maybe<Array<Maybe<ApprovalForAllEvent_Filter>>>;
2930
+ or?: Maybe<Array<Maybe<ApprovalForAllEvent_Filter>>>;
2931
+ };
2932
+ export declare enum ApprovalForAllEvent_OrderBy {
2933
+ Id = "id",
2934
+ TransactionHash = "transactionHash",
2935
+ GasPrice = "gasPrice",
2936
+ GasUsed = "gasUsed",
2937
+ Timestamp = "timestamp",
2938
+ Name = "name",
2939
+ Addresses = "addresses",
2940
+ BlockNumber = "blockNumber",
2941
+ LogIndex = "logIndex",
2942
+ Order = "order",
2943
+ Owner = "owner",
2944
+ Owner__id = "owner__id",
2945
+ Owner__createdAtTimestamp = "owner__createdAtTimestamp",
2946
+ Owner__createdAtBlockNumber = "owner__createdAtBlockNumber",
2947
+ Owner__updatedAtTimestamp = "owner__updatedAtTimestamp",
2948
+ Owner__updatedAtBlockNumber = "owner__updatedAtBlockNumber",
2949
+ Owner__isSuperApp = "owner__isSuperApp",
2950
+ Operator = "operator",
2951
+ Operator__id = "operator__id",
2952
+ Operator__createdAtTimestamp = "operator__createdAtTimestamp",
2953
+ Operator__createdAtBlockNumber = "operator__createdAtBlockNumber",
2954
+ Operator__updatedAtTimestamp = "operator__updatedAtTimestamp",
2955
+ Operator__updatedAtBlockNumber = "operator__updatedAtBlockNumber",
2956
+ Operator__isSuperApp = "operator__isSuperApp",
2957
+ Approved = "approved"
2958
+ }
2572
2959
  export type BlockChangedFilter = {
2573
2960
  number_gte: Scalars['Int'];
2574
2961
  };
@@ -4225,6 +4612,7 @@ export type FlowDistributionUpdatedEvent = Event & {
4225
4612
  newTotalDistributionFlowRate: Scalars['BigInt'];
4226
4613
  adjustmentFlowRecipient: Scalars['Bytes'];
4227
4614
  adjustmentFlowRate: Scalars['BigInt'];
4615
+ userData: Scalars['Bytes'];
4228
4616
  pool: Pool;
4229
4617
  poolDistributor: PoolDistributor;
4230
4618
  };
@@ -4383,6 +4771,16 @@ export type FlowDistributionUpdatedEvent_Filter = {
4383
4771
  adjustmentFlowRate_lte?: Maybe<Scalars['BigInt']>;
4384
4772
  adjustmentFlowRate_in?: Maybe<Array<Scalars['BigInt']>>;
4385
4773
  adjustmentFlowRate_not_in?: Maybe<Array<Scalars['BigInt']>>;
4774
+ userData?: Maybe<Scalars['Bytes']>;
4775
+ userData_not?: Maybe<Scalars['Bytes']>;
4776
+ userData_gt?: Maybe<Scalars['Bytes']>;
4777
+ userData_lt?: Maybe<Scalars['Bytes']>;
4778
+ userData_gte?: Maybe<Scalars['Bytes']>;
4779
+ userData_lte?: Maybe<Scalars['Bytes']>;
4780
+ userData_in?: Maybe<Array<Scalars['Bytes']>>;
4781
+ userData_not_in?: Maybe<Array<Scalars['Bytes']>>;
4782
+ userData_contains?: Maybe<Scalars['Bytes']>;
4783
+ userData_not_contains?: Maybe<Scalars['Bytes']>;
4386
4784
  pool?: Maybe<Scalars['String']>;
4387
4785
  pool_not?: Maybe<Scalars['String']>;
4388
4786
  pool_gt?: Maybe<Scalars['String']>;
@@ -4448,6 +4846,7 @@ export declare enum FlowDistributionUpdatedEvent_OrderBy {
4448
4846
  NewTotalDistributionFlowRate = "newTotalDistributionFlowRate",
4449
4847
  AdjustmentFlowRecipient = "adjustmentFlowRecipient",
4450
4848
  AdjustmentFlowRate = "adjustmentFlowRate",
4849
+ UserData = "userData",
4451
4850
  Pool = "pool",
4452
4851
  Pool__id = "pool__id",
4453
4852
  Pool__createdAtTimestamp = "pool__createdAtTimestamp",
@@ -7386,6 +7785,7 @@ export type InstantDistributionUpdatedEvent = Event & {
7386
7785
  operator: Scalars['Bytes'];
7387
7786
  requestedAmount: Scalars['BigInt'];
7388
7787
  actualAmount: Scalars['BigInt'];
7788
+ userData: Scalars['Bytes'];
7389
7789
  pool: Pool;
7390
7790
  poolDistributor: PoolDistributor;
7391
7791
  };
@@ -7518,6 +7918,16 @@ export type InstantDistributionUpdatedEvent_Filter = {
7518
7918
  actualAmount_lte?: Maybe<Scalars['BigInt']>;
7519
7919
  actualAmount_in?: Maybe<Array<Scalars['BigInt']>>;
7520
7920
  actualAmount_not_in?: Maybe<Array<Scalars['BigInt']>>;
7921
+ userData?: Maybe<Scalars['Bytes']>;
7922
+ userData_not?: Maybe<Scalars['Bytes']>;
7923
+ userData_gt?: Maybe<Scalars['Bytes']>;
7924
+ userData_lt?: Maybe<Scalars['Bytes']>;
7925
+ userData_gte?: Maybe<Scalars['Bytes']>;
7926
+ userData_lte?: Maybe<Scalars['Bytes']>;
7927
+ userData_in?: Maybe<Array<Scalars['Bytes']>>;
7928
+ userData_not_in?: Maybe<Array<Scalars['Bytes']>>;
7929
+ userData_contains?: Maybe<Scalars['Bytes']>;
7930
+ userData_not_contains?: Maybe<Scalars['Bytes']>;
7521
7931
  pool?: Maybe<Scalars['String']>;
7522
7932
  pool_not?: Maybe<Scalars['String']>;
7523
7933
  pool_gt?: Maybe<Scalars['String']>;
@@ -7580,6 +7990,7 @@ export declare enum InstantDistributionUpdatedEvent_OrderBy {
7580
7990
  Operator = "operator",
7581
7991
  RequestedAmount = "requestedAmount",
7582
7992
  ActualAmount = "actualAmount",
7993
+ UserData = "userData",
7583
7994
  Pool = "pool",
7584
7995
  Pool__id = "pool__id",
7585
7996
  Pool__createdAtTimestamp = "pool__createdAtTimestamp",
@@ -7775,6 +8186,7 @@ export type MemberUnitsUpdatedEvent = Event & {
7775
8186
  logIndex: Scalars['BigInt'];
7776
8187
  order: Scalars['BigInt'];
7777
8188
  token: Scalars['Bytes'];
8189
+ oldUnits: Scalars['BigInt'];
7778
8190
  units: Scalars['BigInt'];
7779
8191
  pool: Pool;
7780
8192
  poolMember: PoolMember;
@@ -7882,6 +8294,14 @@ export type MemberUnitsUpdatedEvent_Filter = {
7882
8294
  token_not_in?: Maybe<Array<Scalars['Bytes']>>;
7883
8295
  token_contains?: Maybe<Scalars['Bytes']>;
7884
8296
  token_not_contains?: Maybe<Scalars['Bytes']>;
8297
+ oldUnits?: Maybe<Scalars['BigInt']>;
8298
+ oldUnits_not?: Maybe<Scalars['BigInt']>;
8299
+ oldUnits_gt?: Maybe<Scalars['BigInt']>;
8300
+ oldUnits_lt?: Maybe<Scalars['BigInt']>;
8301
+ oldUnits_gte?: Maybe<Scalars['BigInt']>;
8302
+ oldUnits_lte?: Maybe<Scalars['BigInt']>;
8303
+ oldUnits_in?: Maybe<Array<Scalars['BigInt']>>;
8304
+ oldUnits_not_in?: Maybe<Array<Scalars['BigInt']>>;
7885
8305
  units?: Maybe<Scalars['BigInt']>;
7886
8306
  units_not?: Maybe<Scalars['BigInt']>;
7887
8307
  units_gt?: Maybe<Scalars['BigInt']>;
@@ -7949,6 +8369,7 @@ export declare enum MemberUnitsUpdatedEvent_OrderBy {
7949
8369
  LogIndex = "logIndex",
7950
8370
  Order = "order",
7951
8371
  Token = "token",
8372
+ OldUnits = "oldUnits",
7952
8373
  Units = "units",
7953
8374
  Pool = "pool",
7954
8375
  Pool__id = "pool__id",
@@ -7978,6 +8399,144 @@ export declare enum MemberUnitsUpdatedEvent_OrderBy {
7978
8399
  PoolMember__isConnected = "poolMember__isConnected",
7979
8400
  PoolMember__totalAmountClaimed = "poolMember__totalAmountClaimed"
7980
8401
  }
8402
+ export type MetadataUpdateEvent = Event & {
8403
+ __typename?: 'MetadataUpdateEvent';
8404
+ id: Scalars['ID'];
8405
+ transactionHash: Scalars['Bytes'];
8406
+ gasPrice: Scalars['BigInt'];
8407
+ gasUsed: Scalars['BigInt'];
8408
+ timestamp: Scalars['BigInt'];
8409
+ name: Scalars['String'];
8410
+ /** Empty addresses array. */
8411
+ addresses: Array<Scalars['Bytes']>;
8412
+ blockNumber: Scalars['BigInt'];
8413
+ logIndex: Scalars['BigInt'];
8414
+ order: Scalars['BigInt'];
8415
+ /**
8416
+ * The id of the NFT that will be granted allowance to transfer.
8417
+ * The id is: uint256(keccak256(abi.encode(block.chainid, superToken, sender, receiver)))
8418
+ */
8419
+ tokenId: Scalars['BigInt'];
8420
+ };
8421
+ export type MetadataUpdateEvent_Filter = {
8422
+ id?: Maybe<Scalars['ID']>;
8423
+ id_not?: Maybe<Scalars['ID']>;
8424
+ id_gt?: Maybe<Scalars['ID']>;
8425
+ id_lt?: Maybe<Scalars['ID']>;
8426
+ id_gte?: Maybe<Scalars['ID']>;
8427
+ id_lte?: Maybe<Scalars['ID']>;
8428
+ id_in?: Maybe<Array<Scalars['ID']>>;
8429
+ id_not_in?: Maybe<Array<Scalars['ID']>>;
8430
+ transactionHash?: Maybe<Scalars['Bytes']>;
8431
+ transactionHash_not?: Maybe<Scalars['Bytes']>;
8432
+ transactionHash_gt?: Maybe<Scalars['Bytes']>;
8433
+ transactionHash_lt?: Maybe<Scalars['Bytes']>;
8434
+ transactionHash_gte?: Maybe<Scalars['Bytes']>;
8435
+ transactionHash_lte?: Maybe<Scalars['Bytes']>;
8436
+ transactionHash_in?: Maybe<Array<Scalars['Bytes']>>;
8437
+ transactionHash_not_in?: Maybe<Array<Scalars['Bytes']>>;
8438
+ transactionHash_contains?: Maybe<Scalars['Bytes']>;
8439
+ transactionHash_not_contains?: Maybe<Scalars['Bytes']>;
8440
+ gasPrice?: Maybe<Scalars['BigInt']>;
8441
+ gasPrice_not?: Maybe<Scalars['BigInt']>;
8442
+ gasPrice_gt?: Maybe<Scalars['BigInt']>;
8443
+ gasPrice_lt?: Maybe<Scalars['BigInt']>;
8444
+ gasPrice_gte?: Maybe<Scalars['BigInt']>;
8445
+ gasPrice_lte?: Maybe<Scalars['BigInt']>;
8446
+ gasPrice_in?: Maybe<Array<Scalars['BigInt']>>;
8447
+ gasPrice_not_in?: Maybe<Array<Scalars['BigInt']>>;
8448
+ gasUsed?: Maybe<Scalars['BigInt']>;
8449
+ gasUsed_not?: Maybe<Scalars['BigInt']>;
8450
+ gasUsed_gt?: Maybe<Scalars['BigInt']>;
8451
+ gasUsed_lt?: Maybe<Scalars['BigInt']>;
8452
+ gasUsed_gte?: Maybe<Scalars['BigInt']>;
8453
+ gasUsed_lte?: Maybe<Scalars['BigInt']>;
8454
+ gasUsed_in?: Maybe<Array<Scalars['BigInt']>>;
8455
+ gasUsed_not_in?: Maybe<Array<Scalars['BigInt']>>;
8456
+ timestamp?: Maybe<Scalars['BigInt']>;
8457
+ timestamp_not?: Maybe<Scalars['BigInt']>;
8458
+ timestamp_gt?: Maybe<Scalars['BigInt']>;
8459
+ timestamp_lt?: Maybe<Scalars['BigInt']>;
8460
+ timestamp_gte?: Maybe<Scalars['BigInt']>;
8461
+ timestamp_lte?: Maybe<Scalars['BigInt']>;
8462
+ timestamp_in?: Maybe<Array<Scalars['BigInt']>>;
8463
+ timestamp_not_in?: Maybe<Array<Scalars['BigInt']>>;
8464
+ name?: Maybe<Scalars['String']>;
8465
+ name_not?: Maybe<Scalars['String']>;
8466
+ name_gt?: Maybe<Scalars['String']>;
8467
+ name_lt?: Maybe<Scalars['String']>;
8468
+ name_gte?: Maybe<Scalars['String']>;
8469
+ name_lte?: Maybe<Scalars['String']>;
8470
+ name_in?: Maybe<Array<Scalars['String']>>;
8471
+ name_not_in?: Maybe<Array<Scalars['String']>>;
8472
+ name_contains?: Maybe<Scalars['String']>;
8473
+ name_contains_nocase?: Maybe<Scalars['String']>;
8474
+ name_not_contains?: Maybe<Scalars['String']>;
8475
+ name_not_contains_nocase?: Maybe<Scalars['String']>;
8476
+ name_starts_with?: Maybe<Scalars['String']>;
8477
+ name_starts_with_nocase?: Maybe<Scalars['String']>;
8478
+ name_not_starts_with?: Maybe<Scalars['String']>;
8479
+ name_not_starts_with_nocase?: Maybe<Scalars['String']>;
8480
+ name_ends_with?: Maybe<Scalars['String']>;
8481
+ name_ends_with_nocase?: Maybe<Scalars['String']>;
8482
+ name_not_ends_with?: Maybe<Scalars['String']>;
8483
+ name_not_ends_with_nocase?: Maybe<Scalars['String']>;
8484
+ addresses?: Maybe<Array<Scalars['Bytes']>>;
8485
+ addresses_not?: Maybe<Array<Scalars['Bytes']>>;
8486
+ addresses_contains?: Maybe<Array<Scalars['Bytes']>>;
8487
+ addresses_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
8488
+ addresses_not_contains?: Maybe<Array<Scalars['Bytes']>>;
8489
+ addresses_not_contains_nocase?: Maybe<Array<Scalars['Bytes']>>;
8490
+ blockNumber?: Maybe<Scalars['BigInt']>;
8491
+ blockNumber_not?: Maybe<Scalars['BigInt']>;
8492
+ blockNumber_gt?: Maybe<Scalars['BigInt']>;
8493
+ blockNumber_lt?: Maybe<Scalars['BigInt']>;
8494
+ blockNumber_gte?: Maybe<Scalars['BigInt']>;
8495
+ blockNumber_lte?: Maybe<Scalars['BigInt']>;
8496
+ blockNumber_in?: Maybe<Array<Scalars['BigInt']>>;
8497
+ blockNumber_not_in?: Maybe<Array<Scalars['BigInt']>>;
8498
+ logIndex?: Maybe<Scalars['BigInt']>;
8499
+ logIndex_not?: Maybe<Scalars['BigInt']>;
8500
+ logIndex_gt?: Maybe<Scalars['BigInt']>;
8501
+ logIndex_lt?: Maybe<Scalars['BigInt']>;
8502
+ logIndex_gte?: Maybe<Scalars['BigInt']>;
8503
+ logIndex_lte?: Maybe<Scalars['BigInt']>;
8504
+ logIndex_in?: Maybe<Array<Scalars['BigInt']>>;
8505
+ logIndex_not_in?: Maybe<Array<Scalars['BigInt']>>;
8506
+ order?: Maybe<Scalars['BigInt']>;
8507
+ order_not?: Maybe<Scalars['BigInt']>;
8508
+ order_gt?: Maybe<Scalars['BigInt']>;
8509
+ order_lt?: Maybe<Scalars['BigInt']>;
8510
+ order_gte?: Maybe<Scalars['BigInt']>;
8511
+ order_lte?: Maybe<Scalars['BigInt']>;
8512
+ order_in?: Maybe<Array<Scalars['BigInt']>>;
8513
+ order_not_in?: Maybe<Array<Scalars['BigInt']>>;
8514
+ tokenId?: Maybe<Scalars['BigInt']>;
8515
+ tokenId_not?: Maybe<Scalars['BigInt']>;
8516
+ tokenId_gt?: Maybe<Scalars['BigInt']>;
8517
+ tokenId_lt?: Maybe<Scalars['BigInt']>;
8518
+ tokenId_gte?: Maybe<Scalars['BigInt']>;
8519
+ tokenId_lte?: Maybe<Scalars['BigInt']>;
8520
+ tokenId_in?: Maybe<Array<Scalars['BigInt']>>;
8521
+ tokenId_not_in?: Maybe<Array<Scalars['BigInt']>>;
8522
+ /** Filter for the block changed event. */
8523
+ _change_block?: Maybe<BlockChangedFilter>;
8524
+ and?: Maybe<Array<Maybe<MetadataUpdateEvent_Filter>>>;
8525
+ or?: Maybe<Array<Maybe<MetadataUpdateEvent_Filter>>>;
8526
+ };
8527
+ export declare enum MetadataUpdateEvent_OrderBy {
8528
+ Id = "id",
8529
+ TransactionHash = "transactionHash",
8530
+ GasPrice = "gasPrice",
8531
+ GasUsed = "gasUsed",
8532
+ Timestamp = "timestamp",
8533
+ Name = "name",
8534
+ Addresses = "addresses",
8535
+ BlockNumber = "blockNumber",
8536
+ LogIndex = "logIndex",
8537
+ Order = "order",
8538
+ TokenId = "tokenId"
8539
+ }
7981
8540
  export type MintedEvent = Event & {
7982
8541
  __typename?: 'MintedEvent';
7983
8542
  id: Scalars['ID'];
@@ -8577,7 +9136,7 @@ export type Pool = {
8577
9136
  bufferAdjustedEvents: Array<BufferAdjustedEvent>;
8578
9137
  instantDistributionUpdatedEvents: Array<InstantDistributionUpdatedEvent>;
8579
9138
  flowDistributionUpdatedEvents: Array<FlowDistributionUpdatedEvent>;
8580
- poolMemberUnitsUpdatedEvents: Array<MemberUnitsUpdatedEvent>;
9139
+ memberUnitsUpdatedEvents: Array<MemberUnitsUpdatedEvent>;
8581
9140
  distributionClaimedEvents: Array<DistributionClaimedEvent>;
8582
9141
  };
8583
9142
  export type PoolPoolDistributorsArgs = {
@@ -8622,7 +9181,7 @@ export type PoolFlowDistributionUpdatedEventsArgs = {
8622
9181
  orderDirection?: Maybe<OrderDirection>;
8623
9182
  where?: Maybe<FlowDistributionUpdatedEvent_Filter>;
8624
9183
  };
8625
- export type PoolPoolMemberUnitsUpdatedEventsArgs = {
9184
+ export type PoolMemberUnitsUpdatedEventsArgs = {
8626
9185
  skip?: Maybe<Scalars['Int']>;
8627
9186
  first?: Maybe<Scalars['Int']>;
8628
9187
  orderBy?: Maybe<MemberUnitsUpdatedEvent_OrderBy>;
@@ -8656,6 +9215,7 @@ export type PoolConnectionUpdatedEvent = Event & {
8656
9215
  order: Scalars['BigInt'];
8657
9216
  token: Scalars['Bytes'];
8658
9217
  connected: Scalars['Boolean'];
9218
+ userData: Scalars['Bytes'];
8659
9219
  pool: Pool;
8660
9220
  poolMember: PoolMember;
8661
9221
  };
@@ -8766,6 +9326,16 @@ export type PoolConnectionUpdatedEvent_Filter = {
8766
9326
  connected_not?: Maybe<Scalars['Boolean']>;
8767
9327
  connected_in?: Maybe<Array<Scalars['Boolean']>>;
8768
9328
  connected_not_in?: Maybe<Array<Scalars['Boolean']>>;
9329
+ userData?: Maybe<Scalars['Bytes']>;
9330
+ userData_not?: Maybe<Scalars['Bytes']>;
9331
+ userData_gt?: Maybe<Scalars['Bytes']>;
9332
+ userData_lt?: Maybe<Scalars['Bytes']>;
9333
+ userData_gte?: Maybe<Scalars['Bytes']>;
9334
+ userData_lte?: Maybe<Scalars['Bytes']>;
9335
+ userData_in?: Maybe<Array<Scalars['Bytes']>>;
9336
+ userData_not_in?: Maybe<Array<Scalars['Bytes']>>;
9337
+ userData_contains?: Maybe<Scalars['Bytes']>;
9338
+ userData_not_contains?: Maybe<Scalars['Bytes']>;
8769
9339
  pool?: Maybe<Scalars['String']>;
8770
9340
  pool_not?: Maybe<Scalars['String']>;
8771
9341
  pool_gt?: Maybe<Scalars['String']>;
@@ -8826,6 +9396,7 @@ export declare enum PoolConnectionUpdatedEvent_OrderBy {
8826
9396
  Order = "order",
8827
9397
  Token = "token",
8828
9398
  Connected = "connected",
9399
+ UserData = "userData",
8829
9400
  Pool = "pool",
8830
9401
  Pool__id = "pool__id",
8831
9402
  Pool__createdAtTimestamp = "pool__createdAtTimestamp",
@@ -9285,7 +9856,7 @@ export type PoolMember = {
9285
9856
  account: Account;
9286
9857
  pool: Pool;
9287
9858
  poolConnectionUpdatedEvents: Array<PoolConnectionUpdatedEvent>;
9288
- poolMemberUnitsUpdatedEvents: Array<MemberUnitsUpdatedEvent>;
9859
+ memberUnitsUpdatedEvents: Array<MemberUnitsUpdatedEvent>;
9289
9860
  distributionClaimedEvents: Array<DistributionClaimedEvent>;
9290
9861
  };
9291
9862
  export type PoolMemberPoolConnectionUpdatedEventsArgs = {
@@ -9295,7 +9866,7 @@ export type PoolMemberPoolConnectionUpdatedEventsArgs = {
9295
9866
  orderDirection?: Maybe<OrderDirection>;
9296
9867
  where?: Maybe<PoolConnectionUpdatedEvent_Filter>;
9297
9868
  };
9298
- export type PoolMemberPoolMemberUnitsUpdatedEventsArgs = {
9869
+ export type PoolMemberMemberUnitsUpdatedEventsArgs = {
9299
9870
  skip?: Maybe<Scalars['Int']>;
9300
9871
  first?: Maybe<Scalars['Int']>;
9301
9872
  orderBy?: Maybe<MemberUnitsUpdatedEvent_OrderBy>;
@@ -9413,7 +9984,7 @@ export type PoolMember_Filter = {
9413
9984
  pool_not_ends_with_nocase?: Maybe<Scalars['String']>;
9414
9985
  pool_?: Maybe<Pool_Filter>;
9415
9986
  poolConnectionUpdatedEvents_?: Maybe<PoolConnectionUpdatedEvent_Filter>;
9416
- poolMemberUnitsUpdatedEvents_?: Maybe<MemberUnitsUpdatedEvent_Filter>;
9987
+ memberUnitsUpdatedEvents_?: Maybe<MemberUnitsUpdatedEvent_Filter>;
9417
9988
  distributionClaimedEvents_?: Maybe<DistributionClaimedEvent_Filter>;
9418
9989
  /** Filter for the block changed event. */
9419
9990
  _change_block?: Maybe<BlockChangedFilter>;
@@ -9455,7 +10026,7 @@ export declare enum PoolMember_OrderBy {
9455
10026
  Pool__flowRate = "pool__flowRate",
9456
10027
  Pool__totalBuffer = "pool__totalBuffer",
9457
10028
  PoolConnectionUpdatedEvents = "poolConnectionUpdatedEvents",
9458
- PoolMemberUnitsUpdatedEvents = "poolMemberUnitsUpdatedEvents",
10029
+ MemberUnitsUpdatedEvents = "memberUnitsUpdatedEvents",
9459
10030
  DistributionClaimedEvents = "distributionClaimedEvents"
9460
10031
  }
9461
10032
  export type Pool_Filter = {
@@ -9644,7 +10215,7 @@ export type Pool_Filter = {
9644
10215
  bufferAdjustedEvents_?: Maybe<BufferAdjustedEvent_Filter>;
9645
10216
  instantDistributionUpdatedEvents_?: Maybe<InstantDistributionUpdatedEvent_Filter>;
9646
10217
  flowDistributionUpdatedEvents_?: Maybe<FlowDistributionUpdatedEvent_Filter>;
9647
- poolMemberUnitsUpdatedEvents_?: Maybe<MemberUnitsUpdatedEvent_Filter>;
10218
+ memberUnitsUpdatedEvents_?: Maybe<MemberUnitsUpdatedEvent_Filter>;
9648
10219
  distributionClaimedEvents_?: Maybe<DistributionClaimedEvent_Filter>;
9649
10220
  /** Filter for the block changed event. */
9650
10221
  _change_block?: Maybe<BlockChangedFilter>;
@@ -9706,7 +10277,7 @@ export declare enum Pool_OrderBy {
9706
10277
  BufferAdjustedEvents = "bufferAdjustedEvents",
9707
10278
  InstantDistributionUpdatedEvents = "instantDistributionUpdatedEvents",
9708
10279
  FlowDistributionUpdatedEvents = "flowDistributionUpdatedEvents",
9709
- PoolMemberUnitsUpdatedEvents = "poolMemberUnitsUpdatedEvents",
10280
+ MemberUnitsUpdatedEvents = "memberUnitsUpdatedEvents",
9710
10281
  DistributionClaimedEvents = "distributionClaimedEvents"
9711
10282
  }
9712
10283
  export type Query = {
@@ -9799,6 +10370,12 @@ export type Query = {
9799
10370
  tokenDowngradedEvents: Array<TokenDowngradedEvent>;
9800
10371
  tokenUpgradedEvent?: Maybe<TokenUpgradedEvent>;
9801
10372
  tokenUpgradedEvents: Array<TokenUpgradedEvent>;
10373
+ approvalEvent?: Maybe<ApprovalEvent>;
10374
+ approvalEvents: Array<ApprovalEvent>;
10375
+ approvalForAllEvent?: Maybe<ApprovalForAllEvent>;
10376
+ approvalForAllEvents: Array<ApprovalForAllEvent>;
10377
+ metadataUpdateEvent?: Maybe<MetadataUpdateEvent>;
10378
+ metadataUpdateEvents: Array<MetadataUpdateEvent>;
9802
10379
  customSuperTokenCreatedEvent?: Maybe<CustomSuperTokenCreatedEvent>;
9803
10380
  customSuperTokenCreatedEvents: Array<CustomSuperTokenCreatedEvent>;
9804
10381
  superTokenCreatedEvent?: Maybe<SuperTokenCreatedEvent>;
@@ -10468,6 +11045,48 @@ export type QueryTokenUpgradedEventsArgs = {
10468
11045
  block?: Maybe<Block_Height>;
10469
11046
  subgraphError?: _SubgraphErrorPolicy_;
10470
11047
  };
11048
+ export type QueryApprovalEventArgs = {
11049
+ id: Scalars['ID'];
11050
+ block?: Maybe<Block_Height>;
11051
+ subgraphError?: _SubgraphErrorPolicy_;
11052
+ };
11053
+ export type QueryApprovalEventsArgs = {
11054
+ skip?: Maybe<Scalars['Int']>;
11055
+ first?: Maybe<Scalars['Int']>;
11056
+ orderBy?: Maybe<ApprovalEvent_OrderBy>;
11057
+ orderDirection?: Maybe<OrderDirection>;
11058
+ where?: Maybe<ApprovalEvent_Filter>;
11059
+ block?: Maybe<Block_Height>;
11060
+ subgraphError?: _SubgraphErrorPolicy_;
11061
+ };
11062
+ export type QueryApprovalForAllEventArgs = {
11063
+ id: Scalars['ID'];
11064
+ block?: Maybe<Block_Height>;
11065
+ subgraphError?: _SubgraphErrorPolicy_;
11066
+ };
11067
+ export type QueryApprovalForAllEventsArgs = {
11068
+ skip?: Maybe<Scalars['Int']>;
11069
+ first?: Maybe<Scalars['Int']>;
11070
+ orderBy?: Maybe<ApprovalForAllEvent_OrderBy>;
11071
+ orderDirection?: Maybe<OrderDirection>;
11072
+ where?: Maybe<ApprovalForAllEvent_Filter>;
11073
+ block?: Maybe<Block_Height>;
11074
+ subgraphError?: _SubgraphErrorPolicy_;
11075
+ };
11076
+ export type QueryMetadataUpdateEventArgs = {
11077
+ id: Scalars['ID'];
11078
+ block?: Maybe<Block_Height>;
11079
+ subgraphError?: _SubgraphErrorPolicy_;
11080
+ };
11081
+ export type QueryMetadataUpdateEventsArgs = {
11082
+ skip?: Maybe<Scalars['Int']>;
11083
+ first?: Maybe<Scalars['Int']>;
11084
+ orderBy?: Maybe<MetadataUpdateEvent_OrderBy>;
11085
+ orderDirection?: Maybe<OrderDirection>;
11086
+ where?: Maybe<MetadataUpdateEvent_Filter>;
11087
+ block?: Maybe<Block_Height>;
11088
+ subgraphError?: _SubgraphErrorPolicy_;
11089
+ };
10471
11090
  export type QueryCustomSuperTokenCreatedEventArgs = {
10472
11091
  id: Scalars['ID'];
10473
11092
  block?: Maybe<Block_Height>;
@@ -12774,6 +13393,12 @@ export type Subscription = {
12774
13393
  tokenDowngradedEvents: Array<TokenDowngradedEvent>;
12775
13394
  tokenUpgradedEvent?: Maybe<TokenUpgradedEvent>;
12776
13395
  tokenUpgradedEvents: Array<TokenUpgradedEvent>;
13396
+ approvalEvent?: Maybe<ApprovalEvent>;
13397
+ approvalEvents: Array<ApprovalEvent>;
13398
+ approvalForAllEvent?: Maybe<ApprovalForAllEvent>;
13399
+ approvalForAllEvents: Array<ApprovalForAllEvent>;
13400
+ metadataUpdateEvent?: Maybe<MetadataUpdateEvent>;
13401
+ metadataUpdateEvents: Array<MetadataUpdateEvent>;
12777
13402
  customSuperTokenCreatedEvent?: Maybe<CustomSuperTokenCreatedEvent>;
12778
13403
  customSuperTokenCreatedEvents: Array<CustomSuperTokenCreatedEvent>;
12779
13404
  superTokenCreatedEvent?: Maybe<SuperTokenCreatedEvent>;
@@ -13443,6 +14068,48 @@ export type SubscriptionTokenUpgradedEventsArgs = {
13443
14068
  block?: Maybe<Block_Height>;
13444
14069
  subgraphError?: _SubgraphErrorPolicy_;
13445
14070
  };
14071
+ export type SubscriptionApprovalEventArgs = {
14072
+ id: Scalars['ID'];
14073
+ block?: Maybe<Block_Height>;
14074
+ subgraphError?: _SubgraphErrorPolicy_;
14075
+ };
14076
+ export type SubscriptionApprovalEventsArgs = {
14077
+ skip?: Maybe<Scalars['Int']>;
14078
+ first?: Maybe<Scalars['Int']>;
14079
+ orderBy?: Maybe<ApprovalEvent_OrderBy>;
14080
+ orderDirection?: Maybe<OrderDirection>;
14081
+ where?: Maybe<ApprovalEvent_Filter>;
14082
+ block?: Maybe<Block_Height>;
14083
+ subgraphError?: _SubgraphErrorPolicy_;
14084
+ };
14085
+ export type SubscriptionApprovalForAllEventArgs = {
14086
+ id: Scalars['ID'];
14087
+ block?: Maybe<Block_Height>;
14088
+ subgraphError?: _SubgraphErrorPolicy_;
14089
+ };
14090
+ export type SubscriptionApprovalForAllEventsArgs = {
14091
+ skip?: Maybe<Scalars['Int']>;
14092
+ first?: Maybe<Scalars['Int']>;
14093
+ orderBy?: Maybe<ApprovalForAllEvent_OrderBy>;
14094
+ orderDirection?: Maybe<OrderDirection>;
14095
+ where?: Maybe<ApprovalForAllEvent_Filter>;
14096
+ block?: Maybe<Block_Height>;
14097
+ subgraphError?: _SubgraphErrorPolicy_;
14098
+ };
14099
+ export type SubscriptionMetadataUpdateEventArgs = {
14100
+ id: Scalars['ID'];
14101
+ block?: Maybe<Block_Height>;
14102
+ subgraphError?: _SubgraphErrorPolicy_;
14103
+ };
14104
+ export type SubscriptionMetadataUpdateEventsArgs = {
14105
+ skip?: Maybe<Scalars['Int']>;
14106
+ first?: Maybe<Scalars['Int']>;
14107
+ orderBy?: Maybe<MetadataUpdateEvent_OrderBy>;
14108
+ orderDirection?: Maybe<OrderDirection>;
14109
+ where?: Maybe<MetadataUpdateEvent_Filter>;
14110
+ block?: Maybe<Block_Height>;
14111
+ subgraphError?: _SubgraphErrorPolicy_;
14112
+ };
13446
14113
  export type SubscriptionCustomSuperTokenCreatedEventArgs = {
13447
14114
  id: Scalars['ID'];
13448
14115
  block?: Maybe<Block_Height>;
@@ -17061,7 +17728,7 @@ export type TransferEvent = Event & {
17061
17728
  name: Scalars['String'];
17062
17729
  /**
17063
17730
  * Contains the addresses that were impacted by this event:
17064
- * addresses[0] = `token` (superToken)
17731
+ * addresses[0] = `token` (superToken if `isNFTTransfer` is false, otherwise the ConstantOutflowNFT or ConstantInflowNFT)
17065
17732
  * addresses[1] = `from`
17066
17733
  * addresses[2] = `to`
17067
17734
  */
@@ -17071,7 +17738,10 @@ export type TransferEvent = Event & {
17071
17738
  order: Scalars['BigInt'];
17072
17739
  from: Account;
17073
17740
  to: Account;
17741
+ isNFTTransfer: Scalars['Boolean'];
17742
+ /** If `isNFTTransfer` is true, value is the `tokenId` of the NFT transferred. */
17074
17743
  value: Scalars['BigInt'];
17744
+ /** If `isNFTTransfer` is true, value is the NFT address, else it is the SuperToken address. */
17075
17745
  token: Scalars['Bytes'];
17076
17746
  };
17077
17747
  export type TransferEvent_Filter = {
@@ -17209,6 +17879,10 @@ export type TransferEvent_Filter = {
17209
17879
  to_not_ends_with?: Maybe<Scalars['String']>;
17210
17880
  to_not_ends_with_nocase?: Maybe<Scalars['String']>;
17211
17881
  to_?: Maybe<Account_Filter>;
17882
+ isNFTTransfer?: Maybe<Scalars['Boolean']>;
17883
+ isNFTTransfer_not?: Maybe<Scalars['Boolean']>;
17884
+ isNFTTransfer_in?: Maybe<Array<Scalars['Boolean']>>;
17885
+ isNFTTransfer_not_in?: Maybe<Array<Scalars['Boolean']>>;
17212
17886
  value?: Maybe<Scalars['BigInt']>;
17213
17887
  value_not?: Maybe<Scalars['BigInt']>;
17214
17888
  value_gt?: Maybe<Scalars['BigInt']>;
@@ -17257,6 +17931,7 @@ export declare enum TransferEvent_OrderBy {
17257
17931
  To__updatedAtTimestamp = "to__updatedAtTimestamp",
17258
17932
  To__updatedAtBlockNumber = "to__updatedAtBlockNumber",
17259
17933
  To__isSuperApp = "to__isSuperApp",
17934
+ IsNFTTransfer = "isNFTTransfer",
17260
17935
  Value = "value",
17261
17936
  Token = "token"
17262
17937
  }