@merkl/api 0.10.421 → 0.10.422

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 (40) hide show
  1. package/dist/database/api/.generated/drizzle/schema.d.ts +127 -0
  2. package/dist/database/api/.generated/drizzle/schema.js +13 -0
  3. package/dist/database/api/.generated/drizzle/schema.ts +15 -0
  4. package/dist/database/api/.generated/edge.js +28 -4
  5. package/dist/database/api/.generated/index-browser.js +25 -1
  6. package/dist/database/api/.generated/index.d.ts +1633 -205
  7. package/dist/database/api/.generated/index.js +28 -4
  8. package/dist/database/api/.generated/package.json +1 -1
  9. package/dist/database/api/.generated/schema.prisma +19 -0
  10. package/dist/database/api/.generated/wasm.js +25 -1
  11. package/dist/src/eden/index.d.ts +75 -115
  12. package/dist/src/index.d.ts +15 -23
  13. package/dist/src/index.js +1 -1
  14. package/dist/src/libs/campaigns/utils/getEulerV2Vaults.d.ts +5 -0
  15. package/dist/src/libs/campaigns/utils/getEulerV2Vaults.js +63 -4
  16. package/dist/src/libs/campaigns/utils/getUniswapV4Pools.js +72 -13
  17. package/dist/src/modules/v4/campaign/campaign.controller.d.ts +1 -1
  18. package/dist/src/modules/v4/campaign/campaign.repository.d.ts +9 -9
  19. package/dist/src/modules/v4/campaign/campaign.service.d.ts +1 -1
  20. package/dist/src/modules/v4/dynamicData/dynamicData.controller.d.ts +1 -1
  21. package/dist/src/modules/v4/interaction/interaction.service.js +2 -3
  22. package/dist/src/modules/v4/opportunity/opportunity.controller.d.ts +3 -3
  23. package/dist/src/modules/v4/opportunity/opportunity.model.d.ts +5 -5
  24. package/dist/src/modules/v4/opportunity/opportunity.repository.d.ts +72 -72
  25. package/dist/src/modules/v4/opportunity/opportunity.service.d.ts +1 -1
  26. package/dist/src/modules/v4/reward/reward.controller.d.ts +4 -12
  27. package/dist/src/modules/v4/reward/reward.repository.d.ts +7 -11
  28. package/dist/src/modules/v4/reward/reward.service.d.ts +5 -10
  29. package/dist/src/modules/v4/router.d.ts +15 -23
  30. package/dist/src/modules/v4/status/status.controller.d.ts +6 -6
  31. package/dist/src/modules/v4/status/status.repository.d.ts +6 -6
  32. package/dist/src/modules/v4/status/status.service.d.ts +6 -6
  33. package/dist/src/modules/v4/token/token.repository.d.ts +2 -2
  34. package/dist/src/modules/v4/token/token.service.d.ts +3 -2
  35. package/dist/src/modules/v4/user/user.repository.d.ts +1 -1
  36. package/dist/src/modules/v4/user/user.service.d.ts +1 -1
  37. package/dist/src/utils/prisma.d.ts +3 -16
  38. package/dist/src/utils/prisma.js +1 -2
  39. package/dist/tsconfig.package.tsbuildinfo +1 -1
  40. package/package.json +1 -1
@@ -128,12 +128,27 @@ export type Blacklist = $Result.DefaultSelection<Prisma.$BlacklistPayload>
128
128
  *
129
129
  */
130
130
  export type Dump = $Result.DefaultSelection<Prisma.$DumpPayload>
131
+ /**
132
+ * Model Logged
133
+ *
134
+ */
135
+ export type Logged = $Result.DefaultSelection<Prisma.$LoggedPayload>
131
136
 
132
137
  /**
133
138
  * Enums
134
139
  */
135
140
  export namespace $Enums {
136
- export const RunStatus: {
141
+ export const LoggedEntityType: {
142
+ UNKNOWN: 'UNKNOWN',
143
+ EULER_VAULT: 'EULER_VAULT',
144
+ UNISWAP_V4: 'UNISWAP_V4',
145
+ COMPOUND_v2: 'COMPOUND_v2'
146
+ };
147
+
148
+ export type LoggedEntityType = (typeof LoggedEntityType)[keyof typeof LoggedEntityType]
149
+
150
+
151
+ export const RunStatus: {
137
152
  PROCESSING: 'PROCESSING',
138
153
  SUCCESS: 'SUCCESS',
139
154
  FAILED: 'FAILED',
@@ -235,6 +250,10 @@ export type PriceSourceMethod = (typeof PriceSourceMethod)[keyof typeof PriceSou
235
250
 
236
251
  }
237
252
 
253
+ export type LoggedEntityType = $Enums.LoggedEntityType
254
+
255
+ export const LoggedEntityType: typeof $Enums.LoggedEntityType
256
+
238
257
  export type RunStatus = $Enums.RunStatus
239
258
 
240
259
  export const RunStatus: typeof $Enums.RunStatus
@@ -621,6 +640,16 @@ export class PrismaClient<
621
640
  * ```
622
641
  */
623
642
  get dump(): Prisma.DumpDelegate<ExtArgs, ClientOptions>;
643
+
644
+ /**
645
+ * `prisma.logged`: Exposes CRUD operations for the **Logged** model.
646
+ * Example usage:
647
+ * ```ts
648
+ * // Fetch zero or more Loggeds
649
+ * const loggeds = await prisma.logged.findMany()
650
+ * ```
651
+ */
652
+ get logged(): Prisma.LoggedDelegate<ExtArgs, ClientOptions>;
624
653
  }
625
654
 
626
655
  export namespace Prisma {
@@ -1083,7 +1112,8 @@ export namespace Prisma {
1083
1112
  MerklRoot: 'MerklRoot',
1084
1113
  PriceSource: 'PriceSource',
1085
1114
  Blacklist: 'Blacklist',
1086
- Dump: 'Dump'
1115
+ Dump: 'Dump',
1116
+ Logged: 'Logged'
1087
1117
  };
1088
1118
 
1089
1119
  export type ModelName = (typeof ModelName)[keyof typeof ModelName]
@@ -1099,7 +1129,7 @@ export namespace Prisma {
1099
1129
 
1100
1130
  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
1101
1131
  meta: {
1102
- modelProps: "campaign" | "campaignStatus" | "campaignComputedValue" | "userComputedValue" | "chain" | "explorer" | "opportunity" | "protocol" | "token" | "aprRecord" | "aprBreakdown" | "tVLRecord" | "tVLBreakdown" | "dailyRewardsRecord" | "dailyRewardsBreakdown" | "user" | "creator" | "reward" | "rewardBreakdown" | "merklRoot" | "priceSource" | "blacklist" | "dump"
1132
+ modelProps: "campaign" | "campaignStatus" | "campaignComputedValue" | "userComputedValue" | "chain" | "explorer" | "opportunity" | "protocol" | "token" | "aprRecord" | "aprBreakdown" | "tVLRecord" | "tVLBreakdown" | "dailyRewardsRecord" | "dailyRewardsBreakdown" | "user" | "creator" | "reward" | "rewardBreakdown" | "merklRoot" | "priceSource" | "blacklist" | "dump" | "logged"
1103
1133
  txIsolationLevel: Prisma.TransactionIsolationLevel
1104
1134
  }
1105
1135
  model: {
@@ -2805,6 +2835,80 @@ export namespace Prisma {
2805
2835
  }
2806
2836
  }
2807
2837
  }
2838
+ Logged: {
2839
+ payload: Prisma.$LoggedPayload<ExtArgs>
2840
+ fields: Prisma.LoggedFieldRefs
2841
+ operations: {
2842
+ findUnique: {
2843
+ args: Prisma.LoggedFindUniqueArgs<ExtArgs>
2844
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload> | null
2845
+ }
2846
+ findUniqueOrThrow: {
2847
+ args: Prisma.LoggedFindUniqueOrThrowArgs<ExtArgs>
2848
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
2849
+ }
2850
+ findFirst: {
2851
+ args: Prisma.LoggedFindFirstArgs<ExtArgs>
2852
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload> | null
2853
+ }
2854
+ findFirstOrThrow: {
2855
+ args: Prisma.LoggedFindFirstOrThrowArgs<ExtArgs>
2856
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
2857
+ }
2858
+ findMany: {
2859
+ args: Prisma.LoggedFindManyArgs<ExtArgs>
2860
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>[]
2861
+ }
2862
+ create: {
2863
+ args: Prisma.LoggedCreateArgs<ExtArgs>
2864
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
2865
+ }
2866
+ createMany: {
2867
+ args: Prisma.LoggedCreateManyArgs<ExtArgs>
2868
+ result: BatchPayload
2869
+ }
2870
+ createManyAndReturn: {
2871
+ args: Prisma.LoggedCreateManyAndReturnArgs<ExtArgs>
2872
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>[]
2873
+ }
2874
+ delete: {
2875
+ args: Prisma.LoggedDeleteArgs<ExtArgs>
2876
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
2877
+ }
2878
+ update: {
2879
+ args: Prisma.LoggedUpdateArgs<ExtArgs>
2880
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
2881
+ }
2882
+ deleteMany: {
2883
+ args: Prisma.LoggedDeleteManyArgs<ExtArgs>
2884
+ result: BatchPayload
2885
+ }
2886
+ updateMany: {
2887
+ args: Prisma.LoggedUpdateManyArgs<ExtArgs>
2888
+ result: BatchPayload
2889
+ }
2890
+ updateManyAndReturn: {
2891
+ args: Prisma.LoggedUpdateManyAndReturnArgs<ExtArgs>
2892
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>[]
2893
+ }
2894
+ upsert: {
2895
+ args: Prisma.LoggedUpsertArgs<ExtArgs>
2896
+ result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
2897
+ }
2898
+ aggregate: {
2899
+ args: Prisma.LoggedAggregateArgs<ExtArgs>
2900
+ result: $Utils.Optional<AggregateLogged>
2901
+ }
2902
+ groupBy: {
2903
+ args: Prisma.LoggedGroupByArgs<ExtArgs>
2904
+ result: $Utils.Optional<LoggedGroupByOutputType>[]
2905
+ }
2906
+ count: {
2907
+ args: Prisma.LoggedCountArgs<ExtArgs>
2908
+ result: $Utils.Optional<LoggedCountAggregateOutputType> | number
2909
+ }
2910
+ }
2911
+ }
2808
2912
  }
2809
2913
  } & {
2810
2914
  other: {
@@ -2912,6 +3016,7 @@ export namespace Prisma {
2912
3016
  priceSource?: PriceSourceOmit
2913
3017
  blacklist?: BlacklistOmit
2914
3018
  dump?: DumpOmit
3019
+ logged?: LoggedOmit
2915
3020
  }
2916
3021
 
2917
3022
  /* Types for Logging */
@@ -29830,439 +29935,1503 @@ export namespace Prisma {
29830
29935
 
29831
29936
 
29832
29937
  /**
29833
- * Fields of the Dump model
29938
+ * Fields of the Dump model
29939
+ */
29940
+ interface DumpFieldRefs {
29941
+ readonly id: FieldRef<"Dump", 'String'>
29942
+ readonly chainId: FieldRef<"Dump", 'Int'>
29943
+ readonly fromTokenId: FieldRef<"Dump", 'String'>
29944
+ readonly toTokenId: FieldRef<"Dump", 'String'>
29945
+ readonly multisig: FieldRef<"Dump", 'String'>
29946
+ readonly recipient: FieldRef<"Dump", 'String'>
29947
+ readonly amountIn: FieldRef<"Dump", 'String'>
29948
+ readonly amountOut: FieldRef<"Dump", 'String'>
29949
+ readonly datetime: FieldRef<"Dump", 'DateTime'>
29950
+ readonly timestamp: FieldRef<"Dump", 'Int'>
29951
+ }
29952
+
29953
+
29954
+ // Custom InputTypes
29955
+ /**
29956
+ * Dump findUnique
29957
+ */
29958
+ export type DumpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29959
+ /**
29960
+ * Select specific fields to fetch from the Dump
29961
+ */
29962
+ select?: DumpSelect<ExtArgs> | null
29963
+ /**
29964
+ * Omit specific fields from the Dump
29965
+ */
29966
+ omit?: DumpOmit<ExtArgs> | null
29967
+ /**
29968
+ * Choose, which related nodes to fetch as well
29969
+ */
29970
+ include?: DumpInclude<ExtArgs> | null
29971
+ /**
29972
+ * Filter, which Dump to fetch.
29973
+ */
29974
+ where: DumpWhereUniqueInput
29975
+ relationLoadStrategy?: RelationLoadStrategy
29976
+ }
29977
+
29978
+ /**
29979
+ * Dump findUniqueOrThrow
29980
+ */
29981
+ export type DumpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29982
+ /**
29983
+ * Select specific fields to fetch from the Dump
29984
+ */
29985
+ select?: DumpSelect<ExtArgs> | null
29986
+ /**
29987
+ * Omit specific fields from the Dump
29988
+ */
29989
+ omit?: DumpOmit<ExtArgs> | null
29990
+ /**
29991
+ * Choose, which related nodes to fetch as well
29992
+ */
29993
+ include?: DumpInclude<ExtArgs> | null
29994
+ /**
29995
+ * Filter, which Dump to fetch.
29996
+ */
29997
+ where: DumpWhereUniqueInput
29998
+ relationLoadStrategy?: RelationLoadStrategy
29999
+ }
30000
+
30001
+ /**
30002
+ * Dump findFirst
30003
+ */
30004
+ export type DumpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30005
+ /**
30006
+ * Select specific fields to fetch from the Dump
30007
+ */
30008
+ select?: DumpSelect<ExtArgs> | null
30009
+ /**
30010
+ * Omit specific fields from the Dump
30011
+ */
30012
+ omit?: DumpOmit<ExtArgs> | null
30013
+ /**
30014
+ * Choose, which related nodes to fetch as well
30015
+ */
30016
+ include?: DumpInclude<ExtArgs> | null
30017
+ /**
30018
+ * Filter, which Dump to fetch.
30019
+ */
30020
+ where?: DumpWhereInput
30021
+ /**
30022
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
30023
+ *
30024
+ * Determine the order of Dumps to fetch.
30025
+ */
30026
+ orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
30027
+ /**
30028
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
30029
+ *
30030
+ * Sets the position for searching for Dumps.
30031
+ */
30032
+ cursor?: DumpWhereUniqueInput
30033
+ /**
30034
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30035
+ *
30036
+ * Take `±n` Dumps from the position of the cursor.
30037
+ */
30038
+ take?: number
30039
+ /**
30040
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30041
+ *
30042
+ * Skip the first `n` Dumps.
30043
+ */
30044
+ skip?: number
30045
+ /**
30046
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
30047
+ *
30048
+ * Filter by unique combinations of Dumps.
30049
+ */
30050
+ distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
30051
+ relationLoadStrategy?: RelationLoadStrategy
30052
+ }
30053
+
30054
+ /**
30055
+ * Dump findFirstOrThrow
30056
+ */
30057
+ export type DumpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30058
+ /**
30059
+ * Select specific fields to fetch from the Dump
30060
+ */
30061
+ select?: DumpSelect<ExtArgs> | null
30062
+ /**
30063
+ * Omit specific fields from the Dump
30064
+ */
30065
+ omit?: DumpOmit<ExtArgs> | null
30066
+ /**
30067
+ * Choose, which related nodes to fetch as well
30068
+ */
30069
+ include?: DumpInclude<ExtArgs> | null
30070
+ /**
30071
+ * Filter, which Dump to fetch.
30072
+ */
30073
+ where?: DumpWhereInput
30074
+ /**
30075
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
30076
+ *
30077
+ * Determine the order of Dumps to fetch.
30078
+ */
30079
+ orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
30080
+ /**
30081
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
30082
+ *
30083
+ * Sets the position for searching for Dumps.
30084
+ */
30085
+ cursor?: DumpWhereUniqueInput
30086
+ /**
30087
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30088
+ *
30089
+ * Take `±n` Dumps from the position of the cursor.
30090
+ */
30091
+ take?: number
30092
+ /**
30093
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30094
+ *
30095
+ * Skip the first `n` Dumps.
30096
+ */
30097
+ skip?: number
30098
+ /**
30099
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
30100
+ *
30101
+ * Filter by unique combinations of Dumps.
30102
+ */
30103
+ distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
30104
+ relationLoadStrategy?: RelationLoadStrategy
30105
+ }
30106
+
30107
+ /**
30108
+ * Dump findMany
30109
+ */
30110
+ export type DumpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30111
+ /**
30112
+ * Select specific fields to fetch from the Dump
30113
+ */
30114
+ select?: DumpSelect<ExtArgs> | null
30115
+ /**
30116
+ * Omit specific fields from the Dump
30117
+ */
30118
+ omit?: DumpOmit<ExtArgs> | null
30119
+ /**
30120
+ * Choose, which related nodes to fetch as well
30121
+ */
30122
+ include?: DumpInclude<ExtArgs> | null
30123
+ /**
30124
+ * Filter, which Dumps to fetch.
30125
+ */
30126
+ where?: DumpWhereInput
30127
+ /**
30128
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
30129
+ *
30130
+ * Determine the order of Dumps to fetch.
30131
+ */
30132
+ orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
30133
+ /**
30134
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
30135
+ *
30136
+ * Sets the position for listing Dumps.
30137
+ */
30138
+ cursor?: DumpWhereUniqueInput
30139
+ /**
30140
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30141
+ *
30142
+ * Take `±n` Dumps from the position of the cursor.
30143
+ */
30144
+ take?: number
30145
+ /**
30146
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30147
+ *
30148
+ * Skip the first `n` Dumps.
30149
+ */
30150
+ skip?: number
30151
+ distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
30152
+ relationLoadStrategy?: RelationLoadStrategy
30153
+ }
30154
+
30155
+ /**
30156
+ * Dump create
30157
+ */
30158
+ export type DumpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30159
+ /**
30160
+ * Select specific fields to fetch from the Dump
30161
+ */
30162
+ select?: DumpSelect<ExtArgs> | null
30163
+ /**
30164
+ * Omit specific fields from the Dump
30165
+ */
30166
+ omit?: DumpOmit<ExtArgs> | null
30167
+ /**
30168
+ * Choose, which related nodes to fetch as well
30169
+ */
30170
+ include?: DumpInclude<ExtArgs> | null
30171
+ /**
30172
+ * The data needed to create a Dump.
30173
+ */
30174
+ data: XOR<DumpCreateInput, DumpUncheckedCreateInput>
30175
+ relationLoadStrategy?: RelationLoadStrategy
30176
+ }
30177
+
30178
+ /**
30179
+ * Dump createMany
30180
+ */
30181
+ export type DumpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30182
+ /**
30183
+ * The data used to create many Dumps.
30184
+ */
30185
+ data: DumpCreateManyInput | DumpCreateManyInput[]
30186
+ skipDuplicates?: boolean
30187
+ }
30188
+
30189
+ /**
30190
+ * Dump createManyAndReturn
30191
+ */
30192
+ export type DumpCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30193
+ /**
30194
+ * Select specific fields to fetch from the Dump
30195
+ */
30196
+ select?: DumpSelectCreateManyAndReturn<ExtArgs> | null
30197
+ /**
30198
+ * Omit specific fields from the Dump
30199
+ */
30200
+ omit?: DumpOmit<ExtArgs> | null
30201
+ /**
30202
+ * The data used to create many Dumps.
30203
+ */
30204
+ data: DumpCreateManyInput | DumpCreateManyInput[]
30205
+ skipDuplicates?: boolean
30206
+ /**
30207
+ * Choose, which related nodes to fetch as well
30208
+ */
30209
+ include?: DumpIncludeCreateManyAndReturn<ExtArgs> | null
30210
+ }
30211
+
30212
+ /**
30213
+ * Dump update
30214
+ */
30215
+ export type DumpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30216
+ /**
30217
+ * Select specific fields to fetch from the Dump
30218
+ */
30219
+ select?: DumpSelect<ExtArgs> | null
30220
+ /**
30221
+ * Omit specific fields from the Dump
30222
+ */
30223
+ omit?: DumpOmit<ExtArgs> | null
30224
+ /**
30225
+ * Choose, which related nodes to fetch as well
30226
+ */
30227
+ include?: DumpInclude<ExtArgs> | null
30228
+ /**
30229
+ * The data needed to update a Dump.
30230
+ */
30231
+ data: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
30232
+ /**
30233
+ * Choose, which Dump to update.
30234
+ */
30235
+ where: DumpWhereUniqueInput
30236
+ relationLoadStrategy?: RelationLoadStrategy
30237
+ }
30238
+
30239
+ /**
30240
+ * Dump updateMany
30241
+ */
30242
+ export type DumpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30243
+ /**
30244
+ * The data used to update Dumps.
30245
+ */
30246
+ data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
30247
+ /**
30248
+ * Filter which Dumps to update
30249
+ */
30250
+ where?: DumpWhereInput
30251
+ /**
30252
+ * Limit how many Dumps to update.
30253
+ */
30254
+ limit?: number
30255
+ }
30256
+
30257
+ /**
30258
+ * Dump updateManyAndReturn
30259
+ */
30260
+ export type DumpUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30261
+ /**
30262
+ * Select specific fields to fetch from the Dump
30263
+ */
30264
+ select?: DumpSelectUpdateManyAndReturn<ExtArgs> | null
30265
+ /**
30266
+ * Omit specific fields from the Dump
30267
+ */
30268
+ omit?: DumpOmit<ExtArgs> | null
30269
+ /**
30270
+ * The data used to update Dumps.
30271
+ */
30272
+ data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
30273
+ /**
30274
+ * Filter which Dumps to update
30275
+ */
30276
+ where?: DumpWhereInput
30277
+ /**
30278
+ * Limit how many Dumps to update.
30279
+ */
30280
+ limit?: number
30281
+ /**
30282
+ * Choose, which related nodes to fetch as well
30283
+ */
30284
+ include?: DumpIncludeUpdateManyAndReturn<ExtArgs> | null
30285
+ }
30286
+
30287
+ /**
30288
+ * Dump upsert
30289
+ */
30290
+ export type DumpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30291
+ /**
30292
+ * Select specific fields to fetch from the Dump
30293
+ */
30294
+ select?: DumpSelect<ExtArgs> | null
30295
+ /**
30296
+ * Omit specific fields from the Dump
30297
+ */
30298
+ omit?: DumpOmit<ExtArgs> | null
30299
+ /**
30300
+ * Choose, which related nodes to fetch as well
30301
+ */
30302
+ include?: DumpInclude<ExtArgs> | null
30303
+ /**
30304
+ * The filter to search for the Dump to update in case it exists.
30305
+ */
30306
+ where: DumpWhereUniqueInput
30307
+ /**
30308
+ * In case the Dump found by the `where` argument doesn't exist, create a new Dump with this data.
30309
+ */
30310
+ create: XOR<DumpCreateInput, DumpUncheckedCreateInput>
30311
+ /**
30312
+ * In case the Dump was found with the provided `where` argument, update it with this data.
30313
+ */
30314
+ update: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
30315
+ relationLoadStrategy?: RelationLoadStrategy
30316
+ }
30317
+
30318
+ /**
30319
+ * Dump delete
30320
+ */
30321
+ export type DumpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30322
+ /**
30323
+ * Select specific fields to fetch from the Dump
30324
+ */
30325
+ select?: DumpSelect<ExtArgs> | null
30326
+ /**
30327
+ * Omit specific fields from the Dump
30328
+ */
30329
+ omit?: DumpOmit<ExtArgs> | null
30330
+ /**
30331
+ * Choose, which related nodes to fetch as well
30332
+ */
30333
+ include?: DumpInclude<ExtArgs> | null
30334
+ /**
30335
+ * Filter which Dump to delete.
30336
+ */
30337
+ where: DumpWhereUniqueInput
30338
+ relationLoadStrategy?: RelationLoadStrategy
30339
+ }
30340
+
30341
+ /**
30342
+ * Dump deleteMany
30343
+ */
30344
+ export type DumpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30345
+ /**
30346
+ * Filter which Dumps to delete
30347
+ */
30348
+ where?: DumpWhereInput
30349
+ /**
30350
+ * Limit how many Dumps to delete.
30351
+ */
30352
+ limit?: number
30353
+ }
30354
+
30355
+ /**
30356
+ * Dump without action
30357
+ */
30358
+ export type DumpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30359
+ /**
30360
+ * Select specific fields to fetch from the Dump
30361
+ */
30362
+ select?: DumpSelect<ExtArgs> | null
30363
+ /**
30364
+ * Omit specific fields from the Dump
30365
+ */
30366
+ omit?: DumpOmit<ExtArgs> | null
30367
+ /**
30368
+ * Choose, which related nodes to fetch as well
30369
+ */
30370
+ include?: DumpInclude<ExtArgs> | null
30371
+ }
30372
+
30373
+
30374
+ /**
30375
+ * Model Logged
30376
+ */
30377
+
30378
+ export type AggregateLogged = {
30379
+ _count: LoggedCountAggregateOutputType | null
30380
+ _avg: LoggedAvgAggregateOutputType | null
30381
+ _sum: LoggedSumAggregateOutputType | null
30382
+ _min: LoggedMinAggregateOutputType | null
30383
+ _max: LoggedMaxAggregateOutputType | null
30384
+ }
30385
+
30386
+ export type LoggedAvgAggregateOutputType = {
30387
+ chainId: number | null
30388
+ fetchAtBlock: number | null
30389
+ }
30390
+
30391
+ export type LoggedSumAggregateOutputType = {
30392
+ chainId: number | null
30393
+ fetchAtBlock: number | null
30394
+ }
30395
+
30396
+ export type LoggedMinAggregateOutputType = {
30397
+ id: string | null
30398
+ chainId: number | null
30399
+ type: $Enums.LoggedEntityType | null
30400
+ address: string | null
30401
+ fetchAtBlock: number | null
30402
+ caughtFromAddress: string | null
30403
+ }
30404
+
30405
+ export type LoggedMaxAggregateOutputType = {
30406
+ id: string | null
30407
+ chainId: number | null
30408
+ type: $Enums.LoggedEntityType | null
30409
+ address: string | null
30410
+ fetchAtBlock: number | null
30411
+ caughtFromAddress: string | null
30412
+ }
30413
+
30414
+ export type LoggedCountAggregateOutputType = {
30415
+ id: number
30416
+ chainId: number
30417
+ type: number
30418
+ address: number
30419
+ fetchAtBlock: number
30420
+ caughtFromAddress: number
30421
+ entityData: number
30422
+ _all: number
30423
+ }
30424
+
30425
+
30426
+ export type LoggedAvgAggregateInputType = {
30427
+ chainId?: true
30428
+ fetchAtBlock?: true
30429
+ }
30430
+
30431
+ export type LoggedSumAggregateInputType = {
30432
+ chainId?: true
30433
+ fetchAtBlock?: true
30434
+ }
30435
+
30436
+ export type LoggedMinAggregateInputType = {
30437
+ id?: true
30438
+ chainId?: true
30439
+ type?: true
30440
+ address?: true
30441
+ fetchAtBlock?: true
30442
+ caughtFromAddress?: true
30443
+ }
30444
+
30445
+ export type LoggedMaxAggregateInputType = {
30446
+ id?: true
30447
+ chainId?: true
30448
+ type?: true
30449
+ address?: true
30450
+ fetchAtBlock?: true
30451
+ caughtFromAddress?: true
30452
+ }
30453
+
30454
+ export type LoggedCountAggregateInputType = {
30455
+ id?: true
30456
+ chainId?: true
30457
+ type?: true
30458
+ address?: true
30459
+ fetchAtBlock?: true
30460
+ caughtFromAddress?: true
30461
+ entityData?: true
30462
+ _all?: true
30463
+ }
30464
+
30465
+ export type LoggedAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30466
+ /**
30467
+ * Filter which Logged to aggregate.
30468
+ */
30469
+ where?: LoggedWhereInput
30470
+ /**
30471
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
30472
+ *
30473
+ * Determine the order of Loggeds to fetch.
30474
+ */
30475
+ orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
30476
+ /**
30477
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
30478
+ *
30479
+ * Sets the start position
30480
+ */
30481
+ cursor?: LoggedWhereUniqueInput
30482
+ /**
30483
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30484
+ *
30485
+ * Take `±n` Loggeds from the position of the cursor.
30486
+ */
30487
+ take?: number
30488
+ /**
30489
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30490
+ *
30491
+ * Skip the first `n` Loggeds.
30492
+ */
30493
+ skip?: number
30494
+ /**
30495
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
30496
+ *
30497
+ * Count returned Loggeds
30498
+ **/
30499
+ _count?: true | LoggedCountAggregateInputType
30500
+ /**
30501
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
30502
+ *
30503
+ * Select which fields to average
30504
+ **/
30505
+ _avg?: LoggedAvgAggregateInputType
30506
+ /**
30507
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
30508
+ *
30509
+ * Select which fields to sum
30510
+ **/
30511
+ _sum?: LoggedSumAggregateInputType
30512
+ /**
30513
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
30514
+ *
30515
+ * Select which fields to find the minimum value
30516
+ **/
30517
+ _min?: LoggedMinAggregateInputType
30518
+ /**
30519
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
30520
+ *
30521
+ * Select which fields to find the maximum value
30522
+ **/
30523
+ _max?: LoggedMaxAggregateInputType
30524
+ }
30525
+
30526
+ export type GetLoggedAggregateType<T extends LoggedAggregateArgs> = {
30527
+ [P in keyof T & keyof AggregateLogged]: P extends '_count' | 'count'
30528
+ ? T[P] extends true
30529
+ ? number
30530
+ : GetScalarType<T[P], AggregateLogged[P]>
30531
+ : GetScalarType<T[P], AggregateLogged[P]>
30532
+ }
30533
+
30534
+
30535
+
30536
+
30537
+ export type LoggedGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30538
+ where?: LoggedWhereInput
30539
+ orderBy?: LoggedOrderByWithAggregationInput | LoggedOrderByWithAggregationInput[]
30540
+ by: LoggedScalarFieldEnum[] | LoggedScalarFieldEnum
30541
+ having?: LoggedScalarWhereWithAggregatesInput
30542
+ take?: number
30543
+ skip?: number
30544
+ _count?: LoggedCountAggregateInputType | true
30545
+ _avg?: LoggedAvgAggregateInputType
30546
+ _sum?: LoggedSumAggregateInputType
30547
+ _min?: LoggedMinAggregateInputType
30548
+ _max?: LoggedMaxAggregateInputType
30549
+ }
30550
+
30551
+ export type LoggedGroupByOutputType = {
30552
+ id: string
30553
+ chainId: number
30554
+ type: $Enums.LoggedEntityType
30555
+ address: string | null
30556
+ fetchAtBlock: number
30557
+ caughtFromAddress: string
30558
+ entityData: JsonValue
30559
+ _count: LoggedCountAggregateOutputType | null
30560
+ _avg: LoggedAvgAggregateOutputType | null
30561
+ _sum: LoggedSumAggregateOutputType | null
30562
+ _min: LoggedMinAggregateOutputType | null
30563
+ _max: LoggedMaxAggregateOutputType | null
30564
+ }
30565
+
30566
+ type GetLoggedGroupByPayload<T extends LoggedGroupByArgs> = Prisma.PrismaPromise<
30567
+ Array<
30568
+ PickEnumerable<LoggedGroupByOutputType, T['by']> &
30569
+ {
30570
+ [P in ((keyof T) & (keyof LoggedGroupByOutputType))]: P extends '_count'
30571
+ ? T[P] extends boolean
30572
+ ? number
30573
+ : GetScalarType<T[P], LoggedGroupByOutputType[P]>
30574
+ : GetScalarType<T[P], LoggedGroupByOutputType[P]>
30575
+ }
30576
+ >
30577
+ >
30578
+
30579
+
30580
+ export type LoggedSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
30581
+ id?: boolean
30582
+ chainId?: boolean
30583
+ type?: boolean
30584
+ address?: boolean
30585
+ fetchAtBlock?: boolean
30586
+ caughtFromAddress?: boolean
30587
+ entityData?: boolean
30588
+ }, ExtArgs["result"]["logged"]>
30589
+
30590
+ export type LoggedSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
30591
+ id?: boolean
30592
+ chainId?: boolean
30593
+ type?: boolean
30594
+ address?: boolean
30595
+ fetchAtBlock?: boolean
30596
+ caughtFromAddress?: boolean
30597
+ entityData?: boolean
30598
+ }, ExtArgs["result"]["logged"]>
30599
+
30600
+ export type LoggedSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
30601
+ id?: boolean
30602
+ chainId?: boolean
30603
+ type?: boolean
30604
+ address?: boolean
30605
+ fetchAtBlock?: boolean
30606
+ caughtFromAddress?: boolean
30607
+ entityData?: boolean
30608
+ }, ExtArgs["result"]["logged"]>
30609
+
30610
+ export type LoggedSelectScalar = {
30611
+ id?: boolean
30612
+ chainId?: boolean
30613
+ type?: boolean
30614
+ address?: boolean
30615
+ fetchAtBlock?: boolean
30616
+ caughtFromAddress?: boolean
30617
+ entityData?: boolean
30618
+ }
30619
+
30620
+ export type LoggedOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "chainId" | "type" | "address" | "fetchAtBlock" | "caughtFromAddress" | "entityData", ExtArgs["result"]["logged"]>
30621
+
30622
+ export type $LoggedPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30623
+ name: "Logged"
30624
+ objects: {}
30625
+ scalars: $Extensions.GetPayloadResult<{
30626
+ id: string
30627
+ chainId: number
30628
+ type: $Enums.LoggedEntityType
30629
+ address: string | null
30630
+ fetchAtBlock: number
30631
+ caughtFromAddress: string
30632
+ entityData: Prisma.JsonValue
30633
+ }, ExtArgs["result"]["logged"]>
30634
+ composites: {}
30635
+ }
30636
+
30637
+ type LoggedGetPayload<S extends boolean | null | undefined | LoggedDefaultArgs> = $Result.GetResult<Prisma.$LoggedPayload, S>
30638
+
30639
+ type LoggedCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
30640
+ Omit<LoggedFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
30641
+ select?: LoggedCountAggregateInputType | true
30642
+ }
30643
+
30644
+ export interface LoggedDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> {
30645
+ [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Logged'], meta: { name: 'Logged' } }
30646
+ /**
30647
+ * Find zero or one Logged that matches the filter.
30648
+ * @param {LoggedFindUniqueArgs} args - Arguments to find a Logged
30649
+ * @example
30650
+ * // Get one Logged
30651
+ * const logged = await prisma.logged.findUnique({
30652
+ * where: {
30653
+ * // ... provide filter here
30654
+ * }
30655
+ * })
30656
+ */
30657
+ findUnique<T extends LoggedFindUniqueArgs>(args: SelectSubset<T, LoggedFindUniqueArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findUnique", ClientOptions> | null, null, ExtArgs, ClientOptions>
30658
+
30659
+ /**
30660
+ * Find one Logged that matches the filter or throw an error with `error.code='P2025'`
30661
+ * if no matches were found.
30662
+ * @param {LoggedFindUniqueOrThrowArgs} args - Arguments to find a Logged
30663
+ * @example
30664
+ * // Get one Logged
30665
+ * const logged = await prisma.logged.findUniqueOrThrow({
30666
+ * where: {
30667
+ * // ... provide filter here
30668
+ * }
30669
+ * })
30670
+ */
30671
+ findUniqueOrThrow<T extends LoggedFindUniqueOrThrowArgs>(args: SelectSubset<T, LoggedFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findUniqueOrThrow", ClientOptions>, never, ExtArgs, ClientOptions>
30672
+
30673
+ /**
30674
+ * Find the first Logged that matches the filter.
30675
+ * Note, that providing `undefined` is treated as the value not being there.
30676
+ * Read more here: https://pris.ly/d/null-undefined
30677
+ * @param {LoggedFindFirstArgs} args - Arguments to find a Logged
30678
+ * @example
30679
+ * // Get one Logged
30680
+ * const logged = await prisma.logged.findFirst({
30681
+ * where: {
30682
+ * // ... provide filter here
30683
+ * }
30684
+ * })
30685
+ */
30686
+ findFirst<T extends LoggedFindFirstArgs>(args?: SelectSubset<T, LoggedFindFirstArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findFirst", ClientOptions> | null, null, ExtArgs, ClientOptions>
30687
+
30688
+ /**
30689
+ * Find the first Logged that matches the filter or
30690
+ * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
30691
+ * Note, that providing `undefined` is treated as the value not being there.
30692
+ * Read more here: https://pris.ly/d/null-undefined
30693
+ * @param {LoggedFindFirstOrThrowArgs} args - Arguments to find a Logged
30694
+ * @example
30695
+ * // Get one Logged
30696
+ * const logged = await prisma.logged.findFirstOrThrow({
30697
+ * where: {
30698
+ * // ... provide filter here
30699
+ * }
30700
+ * })
30701
+ */
30702
+ findFirstOrThrow<T extends LoggedFindFirstOrThrowArgs>(args?: SelectSubset<T, LoggedFindFirstOrThrowArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findFirstOrThrow", ClientOptions>, never, ExtArgs, ClientOptions>
30703
+
30704
+ /**
30705
+ * Find zero or more Loggeds that matches the filter.
30706
+ * Note, that providing `undefined` is treated as the value not being there.
30707
+ * Read more here: https://pris.ly/d/null-undefined
30708
+ * @param {LoggedFindManyArgs} args - Arguments to filter and select certain fields only.
30709
+ * @example
30710
+ * // Get all Loggeds
30711
+ * const loggeds = await prisma.logged.findMany()
30712
+ *
30713
+ * // Get first 10 Loggeds
30714
+ * const loggeds = await prisma.logged.findMany({ take: 10 })
30715
+ *
30716
+ * // Only select the `id`
30717
+ * const loggedWithIdOnly = await prisma.logged.findMany({ select: { id: true } })
30718
+ *
30719
+ */
30720
+ findMany<T extends LoggedFindManyArgs>(args?: SelectSubset<T, LoggedFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findMany", ClientOptions>>
30721
+
30722
+ /**
30723
+ * Create a Logged.
30724
+ * @param {LoggedCreateArgs} args - Arguments to create a Logged.
30725
+ * @example
30726
+ * // Create one Logged
30727
+ * const Logged = await prisma.logged.create({
30728
+ * data: {
30729
+ * // ... data to create a Logged
30730
+ * }
30731
+ * })
30732
+ *
30733
+ */
30734
+ create<T extends LoggedCreateArgs>(args: SelectSubset<T, LoggedCreateArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "create", ClientOptions>, never, ExtArgs, ClientOptions>
30735
+
30736
+ /**
30737
+ * Create many Loggeds.
30738
+ * @param {LoggedCreateManyArgs} args - Arguments to create many Loggeds.
30739
+ * @example
30740
+ * // Create many Loggeds
30741
+ * const logged = await prisma.logged.createMany({
30742
+ * data: [
30743
+ * // ... provide data here
30744
+ * ]
30745
+ * })
30746
+ *
30747
+ */
30748
+ createMany<T extends LoggedCreateManyArgs>(args?: SelectSubset<T, LoggedCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
30749
+
30750
+ /**
30751
+ * Create many Loggeds and returns the data saved in the database.
30752
+ * @param {LoggedCreateManyAndReturnArgs} args - Arguments to create many Loggeds.
30753
+ * @example
30754
+ * // Create many Loggeds
30755
+ * const logged = await prisma.logged.createManyAndReturn({
30756
+ * data: [
30757
+ * // ... provide data here
30758
+ * ]
30759
+ * })
30760
+ *
30761
+ * // Create many Loggeds and only return the `id`
30762
+ * const loggedWithIdOnly = await prisma.logged.createManyAndReturn({
30763
+ * select: { id: true },
30764
+ * data: [
30765
+ * // ... provide data here
30766
+ * ]
30767
+ * })
30768
+ * Note, that providing `undefined` is treated as the value not being there.
30769
+ * Read more here: https://pris.ly/d/null-undefined
30770
+ *
30771
+ */
30772
+ createManyAndReturn<T extends LoggedCreateManyAndReturnArgs>(args?: SelectSubset<T, LoggedCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "createManyAndReturn", ClientOptions>>
30773
+
30774
+ /**
30775
+ * Delete a Logged.
30776
+ * @param {LoggedDeleteArgs} args - Arguments to delete one Logged.
30777
+ * @example
30778
+ * // Delete one Logged
30779
+ * const Logged = await prisma.logged.delete({
30780
+ * where: {
30781
+ * // ... filter to delete one Logged
30782
+ * }
30783
+ * })
30784
+ *
30785
+ */
30786
+ delete<T extends LoggedDeleteArgs>(args: SelectSubset<T, LoggedDeleteArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "delete", ClientOptions>, never, ExtArgs, ClientOptions>
30787
+
30788
+ /**
30789
+ * Update one Logged.
30790
+ * @param {LoggedUpdateArgs} args - Arguments to update one Logged.
30791
+ * @example
30792
+ * // Update one Logged
30793
+ * const logged = await prisma.logged.update({
30794
+ * where: {
30795
+ * // ... provide filter here
30796
+ * },
30797
+ * data: {
30798
+ * // ... provide data here
30799
+ * }
30800
+ * })
30801
+ *
30802
+ */
30803
+ update<T extends LoggedUpdateArgs>(args: SelectSubset<T, LoggedUpdateArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "update", ClientOptions>, never, ExtArgs, ClientOptions>
30804
+
30805
+ /**
30806
+ * Delete zero or more Loggeds.
30807
+ * @param {LoggedDeleteManyArgs} args - Arguments to filter Loggeds to delete.
30808
+ * @example
30809
+ * // Delete a few Loggeds
30810
+ * const { count } = await prisma.logged.deleteMany({
30811
+ * where: {
30812
+ * // ... provide filter here
30813
+ * }
30814
+ * })
30815
+ *
30816
+ */
30817
+ deleteMany<T extends LoggedDeleteManyArgs>(args?: SelectSubset<T, LoggedDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
30818
+
30819
+ /**
30820
+ * Update zero or more Loggeds.
30821
+ * Note, that providing `undefined` is treated as the value not being there.
30822
+ * Read more here: https://pris.ly/d/null-undefined
30823
+ * @param {LoggedUpdateManyArgs} args - Arguments to update one or more rows.
30824
+ * @example
30825
+ * // Update many Loggeds
30826
+ * const logged = await prisma.logged.updateMany({
30827
+ * where: {
30828
+ * // ... provide filter here
30829
+ * },
30830
+ * data: {
30831
+ * // ... provide data here
30832
+ * }
30833
+ * })
30834
+ *
30835
+ */
30836
+ updateMany<T extends LoggedUpdateManyArgs>(args: SelectSubset<T, LoggedUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
30837
+
30838
+ /**
30839
+ * Update zero or more Loggeds and returns the data updated in the database.
30840
+ * @param {LoggedUpdateManyAndReturnArgs} args - Arguments to update many Loggeds.
30841
+ * @example
30842
+ * // Update many Loggeds
30843
+ * const logged = await prisma.logged.updateManyAndReturn({
30844
+ * where: {
30845
+ * // ... provide filter here
30846
+ * },
30847
+ * data: [
30848
+ * // ... provide data here
30849
+ * ]
30850
+ * })
30851
+ *
30852
+ * // Update zero or more Loggeds and only return the `id`
30853
+ * const loggedWithIdOnly = await prisma.logged.updateManyAndReturn({
30854
+ * select: { id: true },
30855
+ * where: {
30856
+ * // ... provide filter here
30857
+ * },
30858
+ * data: [
30859
+ * // ... provide data here
30860
+ * ]
30861
+ * })
30862
+ * Note, that providing `undefined` is treated as the value not being there.
30863
+ * Read more here: https://pris.ly/d/null-undefined
30864
+ *
30865
+ */
30866
+ updateManyAndReturn<T extends LoggedUpdateManyAndReturnArgs>(args: SelectSubset<T, LoggedUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "updateManyAndReturn", ClientOptions>>
30867
+
30868
+ /**
30869
+ * Create or update one Logged.
30870
+ * @param {LoggedUpsertArgs} args - Arguments to update or create a Logged.
30871
+ * @example
30872
+ * // Update or create a Logged
30873
+ * const logged = await prisma.logged.upsert({
30874
+ * create: {
30875
+ * // ... data to create a Logged
30876
+ * },
30877
+ * update: {
30878
+ * // ... in case it already exists, update
30879
+ * },
30880
+ * where: {
30881
+ * // ... the filter for the Logged we want to update
30882
+ * }
30883
+ * })
30884
+ */
30885
+ upsert<T extends LoggedUpsertArgs>(args: SelectSubset<T, LoggedUpsertArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "upsert", ClientOptions>, never, ExtArgs, ClientOptions>
30886
+
30887
+
30888
+ /**
30889
+ * Count the number of Loggeds.
30890
+ * Note, that providing `undefined` is treated as the value not being there.
30891
+ * Read more here: https://pris.ly/d/null-undefined
30892
+ * @param {LoggedCountArgs} args - Arguments to filter Loggeds to count.
30893
+ * @example
30894
+ * // Count the number of Loggeds
30895
+ * const count = await prisma.logged.count({
30896
+ * where: {
30897
+ * // ... the filter for the Loggeds we want to count
30898
+ * }
30899
+ * })
30900
+ **/
30901
+ count<T extends LoggedCountArgs>(
30902
+ args?: Subset<T, LoggedCountArgs>,
30903
+ ): Prisma.PrismaPromise<
30904
+ T extends $Utils.Record<'select', any>
30905
+ ? T['select'] extends true
30906
+ ? number
30907
+ : GetScalarType<T['select'], LoggedCountAggregateOutputType>
30908
+ : number
30909
+ >
30910
+
30911
+ /**
30912
+ * Allows you to perform aggregations operations on a Logged.
30913
+ * Note, that providing `undefined` is treated as the value not being there.
30914
+ * Read more here: https://pris.ly/d/null-undefined
30915
+ * @param {LoggedAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
30916
+ * @example
30917
+ * // Ordered by age ascending
30918
+ * // Where email contains prisma.io
30919
+ * // Limited to the 10 users
30920
+ * const aggregations = await prisma.user.aggregate({
30921
+ * _avg: {
30922
+ * age: true,
30923
+ * },
30924
+ * where: {
30925
+ * email: {
30926
+ * contains: "prisma.io",
30927
+ * },
30928
+ * },
30929
+ * orderBy: {
30930
+ * age: "asc",
30931
+ * },
30932
+ * take: 10,
30933
+ * })
30934
+ **/
30935
+ aggregate<T extends LoggedAggregateArgs>(args: Subset<T, LoggedAggregateArgs>): Prisma.PrismaPromise<GetLoggedAggregateType<T>>
30936
+
30937
+ /**
30938
+ * Group by Logged.
30939
+ * Note, that providing `undefined` is treated as the value not being there.
30940
+ * Read more here: https://pris.ly/d/null-undefined
30941
+ * @param {LoggedGroupByArgs} args - Group by arguments.
30942
+ * @example
30943
+ * // Group by city, order by createdAt, get count
30944
+ * const result = await prisma.user.groupBy({
30945
+ * by: ['city', 'createdAt'],
30946
+ * orderBy: {
30947
+ * createdAt: true
30948
+ * },
30949
+ * _count: {
30950
+ * _all: true
30951
+ * },
30952
+ * })
30953
+ *
30954
+ **/
30955
+ groupBy<
30956
+ T extends LoggedGroupByArgs,
30957
+ HasSelectOrTake extends Or<
30958
+ Extends<'skip', Keys<T>>,
30959
+ Extends<'take', Keys<T>>
30960
+ >,
30961
+ OrderByArg extends True extends HasSelectOrTake
30962
+ ? { orderBy: LoggedGroupByArgs['orderBy'] }
30963
+ : { orderBy?: LoggedGroupByArgs['orderBy'] },
30964
+ OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
30965
+ ByFields extends MaybeTupleToUnion<T['by']>,
30966
+ ByValid extends Has<ByFields, OrderFields>,
30967
+ HavingFields extends GetHavingFields<T['having']>,
30968
+ HavingValid extends Has<ByFields, HavingFields>,
30969
+ ByEmpty extends T['by'] extends never[] ? True : False,
30970
+ InputErrors extends ByEmpty extends True
30971
+ ? `Error: "by" must not be empty.`
30972
+ : HavingValid extends False
30973
+ ? {
30974
+ [P in HavingFields]: P extends ByFields
30975
+ ? never
30976
+ : P extends string
30977
+ ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
30978
+ : [
30979
+ Error,
30980
+ 'Field ',
30981
+ P,
30982
+ ` in "having" needs to be provided in "by"`,
30983
+ ]
30984
+ }[HavingFields]
30985
+ : 'take' extends Keys<T>
30986
+ ? 'orderBy' extends Keys<T>
30987
+ ? ByValid extends True
30988
+ ? {}
30989
+ : {
30990
+ [P in OrderFields]: P extends ByFields
30991
+ ? never
30992
+ : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
30993
+ }[OrderFields]
30994
+ : 'Error: If you provide "take", you also need to provide "orderBy"'
30995
+ : 'skip' extends Keys<T>
30996
+ ? 'orderBy' extends Keys<T>
30997
+ ? ByValid extends True
30998
+ ? {}
30999
+ : {
31000
+ [P in OrderFields]: P extends ByFields
31001
+ ? never
31002
+ : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
31003
+ }[OrderFields]
31004
+ : 'Error: If you provide "skip", you also need to provide "orderBy"'
31005
+ : ByValid extends True
31006
+ ? {}
31007
+ : {
31008
+ [P in OrderFields]: P extends ByFields
31009
+ ? never
31010
+ : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
31011
+ }[OrderFields]
31012
+ >(args: SubsetIntersection<T, LoggedGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLoggedGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
31013
+ /**
31014
+ * Fields of the Logged model
31015
+ */
31016
+ readonly fields: LoggedFieldRefs;
31017
+ }
31018
+
31019
+ /**
31020
+ * The delegate class that acts as a "Promise-like" for Logged.
31021
+ * Why is this prefixed with `Prisma__`?
31022
+ * Because we want to prevent naming conflicts as mentioned in
31023
+ * https://github.com/prisma/prisma-client-js/issues/707
31024
+ */
31025
+ export interface Prisma__LoggedClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> extends Prisma.PrismaPromise<T> {
31026
+ readonly [Symbol.toStringTag]: "PrismaPromise"
31027
+ /**
31028
+ * Attaches callbacks for the resolution and/or rejection of the Promise.
31029
+ * @param onfulfilled The callback to execute when the Promise is resolved.
31030
+ * @param onrejected The callback to execute when the Promise is rejected.
31031
+ * @returns A Promise for the completion of which ever callback is executed.
31032
+ */
31033
+ then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
31034
+ /**
31035
+ * Attaches a callback for only the rejection of the Promise.
31036
+ * @param onrejected The callback to execute when the Promise is rejected.
31037
+ * @returns A Promise for the completion of the callback.
31038
+ */
31039
+ catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
31040
+ /**
31041
+ * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
31042
+ * resolved value cannot be modified from the callback.
31043
+ * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
31044
+ * @returns A Promise for the completion of the callback.
31045
+ */
31046
+ finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
31047
+ }
31048
+
31049
+
31050
+
31051
+
31052
+ /**
31053
+ * Fields of the Logged model
29834
31054
  */
29835
- interface DumpFieldRefs {
29836
- readonly id: FieldRef<"Dump", 'String'>
29837
- readonly chainId: FieldRef<"Dump", 'Int'>
29838
- readonly fromTokenId: FieldRef<"Dump", 'String'>
29839
- readonly toTokenId: FieldRef<"Dump", 'String'>
29840
- readonly multisig: FieldRef<"Dump", 'String'>
29841
- readonly recipient: FieldRef<"Dump", 'String'>
29842
- readonly amountIn: FieldRef<"Dump", 'String'>
29843
- readonly amountOut: FieldRef<"Dump", 'String'>
29844
- readonly datetime: FieldRef<"Dump", 'DateTime'>
29845
- readonly timestamp: FieldRef<"Dump", 'Int'>
31055
+ interface LoggedFieldRefs {
31056
+ readonly id: FieldRef<"Logged", 'String'>
31057
+ readonly chainId: FieldRef<"Logged", 'Int'>
31058
+ readonly type: FieldRef<"Logged", 'LoggedEntityType'>
31059
+ readonly address: FieldRef<"Logged", 'String'>
31060
+ readonly fetchAtBlock: FieldRef<"Logged", 'Int'>
31061
+ readonly caughtFromAddress: FieldRef<"Logged", 'String'>
31062
+ readonly entityData: FieldRef<"Logged", 'Json'>
29846
31063
  }
29847
31064
 
29848
31065
 
29849
31066
  // Custom InputTypes
29850
31067
  /**
29851
- * Dump findUnique
31068
+ * Logged findUnique
29852
31069
  */
29853
- export type DumpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29854
- /**
29855
- * Select specific fields to fetch from the Dump
29856
- */
29857
- select?: DumpSelect<ExtArgs> | null
31070
+ export type LoggedFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29858
31071
  /**
29859
- * Omit specific fields from the Dump
31072
+ * Select specific fields to fetch from the Logged
29860
31073
  */
29861
- omit?: DumpOmit<ExtArgs> | null
31074
+ select?: LoggedSelect<ExtArgs> | null
29862
31075
  /**
29863
- * Choose, which related nodes to fetch as well
31076
+ * Omit specific fields from the Logged
29864
31077
  */
29865
- include?: DumpInclude<ExtArgs> | null
31078
+ omit?: LoggedOmit<ExtArgs> | null
29866
31079
  /**
29867
- * Filter, which Dump to fetch.
31080
+ * Filter, which Logged to fetch.
29868
31081
  */
29869
- where: DumpWhereUniqueInput
31082
+ where: LoggedWhereUniqueInput
29870
31083
  relationLoadStrategy?: RelationLoadStrategy
29871
31084
  }
29872
31085
 
29873
31086
  /**
29874
- * Dump findUniqueOrThrow
31087
+ * Logged findUniqueOrThrow
29875
31088
  */
29876
- export type DumpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29877
- /**
29878
- * Select specific fields to fetch from the Dump
29879
- */
29880
- select?: DumpSelect<ExtArgs> | null
31089
+ export type LoggedFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29881
31090
  /**
29882
- * Omit specific fields from the Dump
31091
+ * Select specific fields to fetch from the Logged
29883
31092
  */
29884
- omit?: DumpOmit<ExtArgs> | null
31093
+ select?: LoggedSelect<ExtArgs> | null
29885
31094
  /**
29886
- * Choose, which related nodes to fetch as well
31095
+ * Omit specific fields from the Logged
29887
31096
  */
29888
- include?: DumpInclude<ExtArgs> | null
31097
+ omit?: LoggedOmit<ExtArgs> | null
29889
31098
  /**
29890
- * Filter, which Dump to fetch.
31099
+ * Filter, which Logged to fetch.
29891
31100
  */
29892
- where: DumpWhereUniqueInput
31101
+ where: LoggedWhereUniqueInput
29893
31102
  relationLoadStrategy?: RelationLoadStrategy
29894
31103
  }
29895
31104
 
29896
31105
  /**
29897
- * Dump findFirst
31106
+ * Logged findFirst
29898
31107
  */
29899
- export type DumpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31108
+ export type LoggedFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29900
31109
  /**
29901
- * Select specific fields to fetch from the Dump
31110
+ * Select specific fields to fetch from the Logged
29902
31111
  */
29903
- select?: DumpSelect<ExtArgs> | null
31112
+ select?: LoggedSelect<ExtArgs> | null
29904
31113
  /**
29905
- * Omit specific fields from the Dump
29906
- */
29907
- omit?: DumpOmit<ExtArgs> | null
29908
- /**
29909
- * Choose, which related nodes to fetch as well
31114
+ * Omit specific fields from the Logged
29910
31115
  */
29911
- include?: DumpInclude<ExtArgs> | null
31116
+ omit?: LoggedOmit<ExtArgs> | null
29912
31117
  /**
29913
- * Filter, which Dump to fetch.
31118
+ * Filter, which Logged to fetch.
29914
31119
  */
29915
- where?: DumpWhereInput
31120
+ where?: LoggedWhereInput
29916
31121
  /**
29917
31122
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
29918
31123
  *
29919
- * Determine the order of Dumps to fetch.
31124
+ * Determine the order of Loggeds to fetch.
29920
31125
  */
29921
- orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
31126
+ orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
29922
31127
  /**
29923
31128
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
29924
31129
  *
29925
- * Sets the position for searching for Dumps.
31130
+ * Sets the position for searching for Loggeds.
29926
31131
  */
29927
- cursor?: DumpWhereUniqueInput
31132
+ cursor?: LoggedWhereUniqueInput
29928
31133
  /**
29929
31134
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
29930
31135
  *
29931
- * Take `±n` Dumps from the position of the cursor.
31136
+ * Take `±n` Loggeds from the position of the cursor.
29932
31137
  */
29933
31138
  take?: number
29934
31139
  /**
29935
31140
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
29936
31141
  *
29937
- * Skip the first `n` Dumps.
31142
+ * Skip the first `n` Loggeds.
29938
31143
  */
29939
31144
  skip?: number
29940
31145
  /**
29941
31146
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
29942
31147
  *
29943
- * Filter by unique combinations of Dumps.
31148
+ * Filter by unique combinations of Loggeds.
29944
31149
  */
29945
- distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
31150
+ distinct?: LoggedScalarFieldEnum | LoggedScalarFieldEnum[]
29946
31151
  relationLoadStrategy?: RelationLoadStrategy
29947
31152
  }
29948
31153
 
29949
31154
  /**
29950
- * Dump findFirstOrThrow
31155
+ * Logged findFirstOrThrow
29951
31156
  */
29952
- export type DumpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31157
+ export type LoggedFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
29953
31158
  /**
29954
- * Select specific fields to fetch from the Dump
31159
+ * Select specific fields to fetch from the Logged
29955
31160
  */
29956
- select?: DumpSelect<ExtArgs> | null
31161
+ select?: LoggedSelect<ExtArgs> | null
29957
31162
  /**
29958
- * Omit specific fields from the Dump
29959
- */
29960
- omit?: DumpOmit<ExtArgs> | null
29961
- /**
29962
- * Choose, which related nodes to fetch as well
31163
+ * Omit specific fields from the Logged
29963
31164
  */
29964
- include?: DumpInclude<ExtArgs> | null
31165
+ omit?: LoggedOmit<ExtArgs> | null
29965
31166
  /**
29966
- * Filter, which Dump to fetch.
31167
+ * Filter, which Logged to fetch.
29967
31168
  */
29968
- where?: DumpWhereInput
31169
+ where?: LoggedWhereInput
29969
31170
  /**
29970
31171
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
29971
31172
  *
29972
- * Determine the order of Dumps to fetch.
31173
+ * Determine the order of Loggeds to fetch.
29973
31174
  */
29974
- orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
31175
+ orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
29975
31176
  /**
29976
31177
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
29977
31178
  *
29978
- * Sets the position for searching for Dumps.
31179
+ * Sets the position for searching for Loggeds.
29979
31180
  */
29980
- cursor?: DumpWhereUniqueInput
31181
+ cursor?: LoggedWhereUniqueInput
29981
31182
  /**
29982
31183
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
29983
31184
  *
29984
- * Take `±n` Dumps from the position of the cursor.
31185
+ * Take `±n` Loggeds from the position of the cursor.
29985
31186
  */
29986
31187
  take?: number
29987
31188
  /**
29988
31189
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
29989
31190
  *
29990
- * Skip the first `n` Dumps.
31191
+ * Skip the first `n` Loggeds.
29991
31192
  */
29992
31193
  skip?: number
29993
31194
  /**
29994
31195
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
29995
31196
  *
29996
- * Filter by unique combinations of Dumps.
31197
+ * Filter by unique combinations of Loggeds.
29997
31198
  */
29998
- distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
31199
+ distinct?: LoggedScalarFieldEnum | LoggedScalarFieldEnum[]
29999
31200
  relationLoadStrategy?: RelationLoadStrategy
30000
31201
  }
30001
31202
 
30002
31203
  /**
30003
- * Dump findMany
31204
+ * Logged findMany
30004
31205
  */
30005
- export type DumpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31206
+ export type LoggedFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30006
31207
  /**
30007
- * Select specific fields to fetch from the Dump
31208
+ * Select specific fields to fetch from the Logged
30008
31209
  */
30009
- select?: DumpSelect<ExtArgs> | null
30010
- /**
30011
- * Omit specific fields from the Dump
30012
- */
30013
- omit?: DumpOmit<ExtArgs> | null
31210
+ select?: LoggedSelect<ExtArgs> | null
30014
31211
  /**
30015
- * Choose, which related nodes to fetch as well
31212
+ * Omit specific fields from the Logged
30016
31213
  */
30017
- include?: DumpInclude<ExtArgs> | null
31214
+ omit?: LoggedOmit<ExtArgs> | null
30018
31215
  /**
30019
- * Filter, which Dumps to fetch.
31216
+ * Filter, which Loggeds to fetch.
30020
31217
  */
30021
- where?: DumpWhereInput
31218
+ where?: LoggedWhereInput
30022
31219
  /**
30023
31220
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
30024
31221
  *
30025
- * Determine the order of Dumps to fetch.
31222
+ * Determine the order of Loggeds to fetch.
30026
31223
  */
30027
- orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
31224
+ orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
30028
31225
  /**
30029
31226
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
30030
31227
  *
30031
- * Sets the position for listing Dumps.
31228
+ * Sets the position for listing Loggeds.
30032
31229
  */
30033
- cursor?: DumpWhereUniqueInput
31230
+ cursor?: LoggedWhereUniqueInput
30034
31231
  /**
30035
31232
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30036
31233
  *
30037
- * Take `±n` Dumps from the position of the cursor.
31234
+ * Take `±n` Loggeds from the position of the cursor.
30038
31235
  */
30039
31236
  take?: number
30040
31237
  /**
30041
31238
  * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
30042
31239
  *
30043
- * Skip the first `n` Dumps.
31240
+ * Skip the first `n` Loggeds.
30044
31241
  */
30045
31242
  skip?: number
30046
- distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
31243
+ distinct?: LoggedScalarFieldEnum | LoggedScalarFieldEnum[]
30047
31244
  relationLoadStrategy?: RelationLoadStrategy
30048
31245
  }
30049
31246
 
30050
31247
  /**
30051
- * Dump create
31248
+ * Logged create
30052
31249
  */
30053
- export type DumpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31250
+ export type LoggedCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30054
31251
  /**
30055
- * Select specific fields to fetch from the Dump
31252
+ * Select specific fields to fetch from the Logged
30056
31253
  */
30057
- select?: DumpSelect<ExtArgs> | null
31254
+ select?: LoggedSelect<ExtArgs> | null
30058
31255
  /**
30059
- * Omit specific fields from the Dump
30060
- */
30061
- omit?: DumpOmit<ExtArgs> | null
30062
- /**
30063
- * Choose, which related nodes to fetch as well
31256
+ * Omit specific fields from the Logged
30064
31257
  */
30065
- include?: DumpInclude<ExtArgs> | null
31258
+ omit?: LoggedOmit<ExtArgs> | null
30066
31259
  /**
30067
- * The data needed to create a Dump.
31260
+ * The data needed to create a Logged.
30068
31261
  */
30069
- data: XOR<DumpCreateInput, DumpUncheckedCreateInput>
31262
+ data: XOR<LoggedCreateInput, LoggedUncheckedCreateInput>
30070
31263
  relationLoadStrategy?: RelationLoadStrategy
30071
31264
  }
30072
31265
 
30073
31266
  /**
30074
- * Dump createMany
31267
+ * Logged createMany
30075
31268
  */
30076
- export type DumpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31269
+ export type LoggedCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30077
31270
  /**
30078
- * The data used to create many Dumps.
31271
+ * The data used to create many Loggeds.
30079
31272
  */
30080
- data: DumpCreateManyInput | DumpCreateManyInput[]
31273
+ data: LoggedCreateManyInput | LoggedCreateManyInput[]
30081
31274
  skipDuplicates?: boolean
30082
31275
  }
30083
31276
 
30084
31277
  /**
30085
- * Dump createManyAndReturn
31278
+ * Logged createManyAndReturn
30086
31279
  */
30087
- export type DumpCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31280
+ export type LoggedCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30088
31281
  /**
30089
- * Select specific fields to fetch from the Dump
31282
+ * Select specific fields to fetch from the Logged
30090
31283
  */
30091
- select?: DumpSelectCreateManyAndReturn<ExtArgs> | null
31284
+ select?: LoggedSelectCreateManyAndReturn<ExtArgs> | null
30092
31285
  /**
30093
- * Omit specific fields from the Dump
31286
+ * Omit specific fields from the Logged
30094
31287
  */
30095
- omit?: DumpOmit<ExtArgs> | null
31288
+ omit?: LoggedOmit<ExtArgs> | null
30096
31289
  /**
30097
- * The data used to create many Dumps.
31290
+ * The data used to create many Loggeds.
30098
31291
  */
30099
- data: DumpCreateManyInput | DumpCreateManyInput[]
31292
+ data: LoggedCreateManyInput | LoggedCreateManyInput[]
30100
31293
  skipDuplicates?: boolean
30101
- /**
30102
- * Choose, which related nodes to fetch as well
30103
- */
30104
- include?: DumpIncludeCreateManyAndReturn<ExtArgs> | null
30105
31294
  }
30106
31295
 
30107
31296
  /**
30108
- * Dump update
31297
+ * Logged update
30109
31298
  */
30110
- export type DumpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30111
- /**
30112
- * Select specific fields to fetch from the Dump
30113
- */
30114
- select?: DumpSelect<ExtArgs> | null
31299
+ export type LoggedUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30115
31300
  /**
30116
- * Omit specific fields from the Dump
31301
+ * Select specific fields to fetch from the Logged
30117
31302
  */
30118
- omit?: DumpOmit<ExtArgs> | null
31303
+ select?: LoggedSelect<ExtArgs> | null
30119
31304
  /**
30120
- * Choose, which related nodes to fetch as well
31305
+ * Omit specific fields from the Logged
30121
31306
  */
30122
- include?: DumpInclude<ExtArgs> | null
31307
+ omit?: LoggedOmit<ExtArgs> | null
30123
31308
  /**
30124
- * The data needed to update a Dump.
31309
+ * The data needed to update a Logged.
30125
31310
  */
30126
- data: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
31311
+ data: XOR<LoggedUpdateInput, LoggedUncheckedUpdateInput>
30127
31312
  /**
30128
- * Choose, which Dump to update.
31313
+ * Choose, which Logged to update.
30129
31314
  */
30130
- where: DumpWhereUniqueInput
31315
+ where: LoggedWhereUniqueInput
30131
31316
  relationLoadStrategy?: RelationLoadStrategy
30132
31317
  }
30133
31318
 
30134
31319
  /**
30135
- * Dump updateMany
31320
+ * Logged updateMany
30136
31321
  */
30137
- export type DumpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31322
+ export type LoggedUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30138
31323
  /**
30139
- * The data used to update Dumps.
31324
+ * The data used to update Loggeds.
30140
31325
  */
30141
- data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
31326
+ data: XOR<LoggedUpdateManyMutationInput, LoggedUncheckedUpdateManyInput>
30142
31327
  /**
30143
- * Filter which Dumps to update
31328
+ * Filter which Loggeds to update
30144
31329
  */
30145
- where?: DumpWhereInput
31330
+ where?: LoggedWhereInput
30146
31331
  /**
30147
- * Limit how many Dumps to update.
31332
+ * Limit how many Loggeds to update.
30148
31333
  */
30149
31334
  limit?: number
30150
31335
  }
30151
31336
 
30152
31337
  /**
30153
- * Dump updateManyAndReturn
31338
+ * Logged updateManyAndReturn
30154
31339
  */
30155
- export type DumpUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31340
+ export type LoggedUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30156
31341
  /**
30157
- * Select specific fields to fetch from the Dump
31342
+ * Select specific fields to fetch from the Logged
30158
31343
  */
30159
- select?: DumpSelectUpdateManyAndReturn<ExtArgs> | null
31344
+ select?: LoggedSelectUpdateManyAndReturn<ExtArgs> | null
30160
31345
  /**
30161
- * Omit specific fields from the Dump
31346
+ * Omit specific fields from the Logged
30162
31347
  */
30163
- omit?: DumpOmit<ExtArgs> | null
31348
+ omit?: LoggedOmit<ExtArgs> | null
30164
31349
  /**
30165
- * The data used to update Dumps.
31350
+ * The data used to update Loggeds.
30166
31351
  */
30167
- data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
31352
+ data: XOR<LoggedUpdateManyMutationInput, LoggedUncheckedUpdateManyInput>
30168
31353
  /**
30169
- * Filter which Dumps to update
31354
+ * Filter which Loggeds to update
30170
31355
  */
30171
- where?: DumpWhereInput
31356
+ where?: LoggedWhereInput
30172
31357
  /**
30173
- * Limit how many Dumps to update.
31358
+ * Limit how many Loggeds to update.
30174
31359
  */
30175
31360
  limit?: number
30176
- /**
30177
- * Choose, which related nodes to fetch as well
30178
- */
30179
- include?: DumpIncludeUpdateManyAndReturn<ExtArgs> | null
30180
31361
  }
30181
31362
 
30182
31363
  /**
30183
- * Dump upsert
31364
+ * Logged upsert
30184
31365
  */
30185
- export type DumpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30186
- /**
30187
- * Select specific fields to fetch from the Dump
30188
- */
30189
- select?: DumpSelect<ExtArgs> | null
31366
+ export type LoggedUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30190
31367
  /**
30191
- * Omit specific fields from the Dump
31368
+ * Select specific fields to fetch from the Logged
30192
31369
  */
30193
- omit?: DumpOmit<ExtArgs> | null
31370
+ select?: LoggedSelect<ExtArgs> | null
30194
31371
  /**
30195
- * Choose, which related nodes to fetch as well
31372
+ * Omit specific fields from the Logged
30196
31373
  */
30197
- include?: DumpInclude<ExtArgs> | null
31374
+ omit?: LoggedOmit<ExtArgs> | null
30198
31375
  /**
30199
- * The filter to search for the Dump to update in case it exists.
31376
+ * The filter to search for the Logged to update in case it exists.
30200
31377
  */
30201
- where: DumpWhereUniqueInput
31378
+ where: LoggedWhereUniqueInput
30202
31379
  /**
30203
- * In case the Dump found by the `where` argument doesn't exist, create a new Dump with this data.
31380
+ * In case the Logged found by the `where` argument doesn't exist, create a new Logged with this data.
30204
31381
  */
30205
- create: XOR<DumpCreateInput, DumpUncheckedCreateInput>
31382
+ create: XOR<LoggedCreateInput, LoggedUncheckedCreateInput>
30206
31383
  /**
30207
- * In case the Dump was found with the provided `where` argument, update it with this data.
31384
+ * In case the Logged was found with the provided `where` argument, update it with this data.
30208
31385
  */
30209
- update: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
31386
+ update: XOR<LoggedUpdateInput, LoggedUncheckedUpdateInput>
30210
31387
  relationLoadStrategy?: RelationLoadStrategy
30211
31388
  }
30212
31389
 
30213
31390
  /**
30214
- * Dump delete
31391
+ * Logged delete
30215
31392
  */
30216
- export type DumpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31393
+ export type LoggedDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30217
31394
  /**
30218
- * Select specific fields to fetch from the Dump
30219
- */
30220
- select?: DumpSelect<ExtArgs> | null
30221
- /**
30222
- * Omit specific fields from the Dump
31395
+ * Select specific fields to fetch from the Logged
30223
31396
  */
30224
- omit?: DumpOmit<ExtArgs> | null
31397
+ select?: LoggedSelect<ExtArgs> | null
30225
31398
  /**
30226
- * Choose, which related nodes to fetch as well
31399
+ * Omit specific fields from the Logged
30227
31400
  */
30228
- include?: DumpInclude<ExtArgs> | null
31401
+ omit?: LoggedOmit<ExtArgs> | null
30229
31402
  /**
30230
- * Filter which Dump to delete.
31403
+ * Filter which Logged to delete.
30231
31404
  */
30232
- where: DumpWhereUniqueInput
31405
+ where: LoggedWhereUniqueInput
30233
31406
  relationLoadStrategy?: RelationLoadStrategy
30234
31407
  }
30235
31408
 
30236
31409
  /**
30237
- * Dump deleteMany
31410
+ * Logged deleteMany
30238
31411
  */
30239
- export type DumpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
31412
+ export type LoggedDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30240
31413
  /**
30241
- * Filter which Dumps to delete
31414
+ * Filter which Loggeds to delete
30242
31415
  */
30243
- where?: DumpWhereInput
31416
+ where?: LoggedWhereInput
30244
31417
  /**
30245
- * Limit how many Dumps to delete.
31418
+ * Limit how many Loggeds to delete.
30246
31419
  */
30247
31420
  limit?: number
30248
31421
  }
30249
31422
 
30250
31423
  /**
30251
- * Dump without action
31424
+ * Logged without action
30252
31425
  */
30253
- export type DumpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30254
- /**
30255
- * Select specific fields to fetch from the Dump
30256
- */
30257
- select?: DumpSelect<ExtArgs> | null
31426
+ export type LoggedDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
30258
31427
  /**
30259
- * Omit specific fields from the Dump
31428
+ * Select specific fields to fetch from the Logged
30260
31429
  */
30261
- omit?: DumpOmit<ExtArgs> | null
31430
+ select?: LoggedSelect<ExtArgs> | null
30262
31431
  /**
30263
- * Choose, which related nodes to fetch as well
31432
+ * Omit specific fields from the Logged
30264
31433
  */
30265
- include?: DumpInclude<ExtArgs> | null
31434
+ omit?: LoggedOmit<ExtArgs> | null
30266
31435
  }
30267
31436
 
30268
31437
 
@@ -30563,6 +31732,19 @@ export namespace Prisma {
30563
31732
  export type DumpScalarFieldEnum = (typeof DumpScalarFieldEnum)[keyof typeof DumpScalarFieldEnum]
30564
31733
 
30565
31734
 
31735
+ export const LoggedScalarFieldEnum: {
31736
+ id: 'id',
31737
+ chainId: 'chainId',
31738
+ type: 'type',
31739
+ address: 'address',
31740
+ fetchAtBlock: 'fetchAtBlock',
31741
+ caughtFromAddress: 'caughtFromAddress',
31742
+ entityData: 'entityData'
31743
+ };
31744
+
31745
+ export type LoggedScalarFieldEnum = (typeof LoggedScalarFieldEnum)[keyof typeof LoggedScalarFieldEnum]
31746
+
31747
+
30566
31748
  export const SortOrder: {
30567
31749
  asc: 'asc',
30568
31750
  desc: 'desc'
@@ -30828,6 +32010,15 @@ export namespace Prisma {
30828
32010
  export type DumpOrderByRelevanceFieldEnum = (typeof DumpOrderByRelevanceFieldEnum)[keyof typeof DumpOrderByRelevanceFieldEnum]
30829
32011
 
30830
32012
 
32013
+ export const LoggedOrderByRelevanceFieldEnum: {
32014
+ id: 'id',
32015
+ address: 'address',
32016
+ caughtFromAddress: 'caughtFromAddress'
32017
+ };
32018
+
32019
+ export type LoggedOrderByRelevanceFieldEnum = (typeof LoggedOrderByRelevanceFieldEnum)[keyof typeof LoggedOrderByRelevanceFieldEnum]
32020
+
32021
+
30831
32022
  /**
30832
32023
  * Field references
30833
32024
  */
@@ -31027,6 +32218,20 @@ export namespace Prisma {
31027
32218
  */
31028
32219
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
31029
32220
 
32221
+
32222
+
32223
+ /**
32224
+ * Reference to a field of type 'LoggedEntityType'
32225
+ */
32226
+ export type EnumLoggedEntityTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LoggedEntityType'>
32227
+
32228
+
32229
+
32230
+ /**
32231
+ * Reference to a field of type 'LoggedEntityType[]'
32232
+ */
32233
+ export type ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LoggedEntityType[]'>
32234
+
31030
32235
  /**
31031
32236
  * Deep Input Types
31032
32237
  */
@@ -32621,6 +33826,72 @@ export namespace Prisma {
32621
33826
  timestamp?: IntWithAggregatesFilter<"Dump"> | number
32622
33827
  }
32623
33828
 
33829
+ export type LoggedWhereInput = {
33830
+ AND?: LoggedWhereInput | LoggedWhereInput[]
33831
+ OR?: LoggedWhereInput[]
33832
+ NOT?: LoggedWhereInput | LoggedWhereInput[]
33833
+ id?: StringFilter<"Logged"> | string
33834
+ chainId?: IntFilter<"Logged"> | number
33835
+ type?: EnumLoggedEntityTypeFilter<"Logged"> | $Enums.LoggedEntityType
33836
+ address?: StringNullableFilter<"Logged"> | string | null
33837
+ fetchAtBlock?: IntFilter<"Logged"> | number
33838
+ caughtFromAddress?: StringFilter<"Logged"> | string
33839
+ entityData?: JsonFilter<"Logged">
33840
+ }
33841
+
33842
+ export type LoggedOrderByWithRelationInput = {
33843
+ id?: SortOrder
33844
+ chainId?: SortOrder
33845
+ type?: SortOrder
33846
+ address?: SortOrderInput | SortOrder
33847
+ fetchAtBlock?: SortOrder
33848
+ caughtFromAddress?: SortOrder
33849
+ entityData?: SortOrder
33850
+ _relevance?: LoggedOrderByRelevanceInput
33851
+ }
33852
+
33853
+ export type LoggedWhereUniqueInput = Prisma.AtLeast<{
33854
+ id?: string
33855
+ chainId_address?: LoggedChainIdAddressCompoundUniqueInput
33856
+ AND?: LoggedWhereInput | LoggedWhereInput[]
33857
+ OR?: LoggedWhereInput[]
33858
+ NOT?: LoggedWhereInput | LoggedWhereInput[]
33859
+ chainId?: IntFilter<"Logged"> | number
33860
+ type?: EnumLoggedEntityTypeFilter<"Logged"> | $Enums.LoggedEntityType
33861
+ address?: StringNullableFilter<"Logged"> | string | null
33862
+ fetchAtBlock?: IntFilter<"Logged"> | number
33863
+ caughtFromAddress?: StringFilter<"Logged"> | string
33864
+ entityData?: JsonFilter<"Logged">
33865
+ }, "id" | "chainId_address">
33866
+
33867
+ export type LoggedOrderByWithAggregationInput = {
33868
+ id?: SortOrder
33869
+ chainId?: SortOrder
33870
+ type?: SortOrder
33871
+ address?: SortOrderInput | SortOrder
33872
+ fetchAtBlock?: SortOrder
33873
+ caughtFromAddress?: SortOrder
33874
+ entityData?: SortOrder
33875
+ _count?: LoggedCountOrderByAggregateInput
33876
+ _avg?: LoggedAvgOrderByAggregateInput
33877
+ _max?: LoggedMaxOrderByAggregateInput
33878
+ _min?: LoggedMinOrderByAggregateInput
33879
+ _sum?: LoggedSumOrderByAggregateInput
33880
+ }
33881
+
33882
+ export type LoggedScalarWhereWithAggregatesInput = {
33883
+ AND?: LoggedScalarWhereWithAggregatesInput | LoggedScalarWhereWithAggregatesInput[]
33884
+ OR?: LoggedScalarWhereWithAggregatesInput[]
33885
+ NOT?: LoggedScalarWhereWithAggregatesInput | LoggedScalarWhereWithAggregatesInput[]
33886
+ id?: StringWithAggregatesFilter<"Logged"> | string
33887
+ chainId?: IntWithAggregatesFilter<"Logged"> | number
33888
+ type?: EnumLoggedEntityTypeWithAggregatesFilter<"Logged"> | $Enums.LoggedEntityType
33889
+ address?: StringNullableWithAggregatesFilter<"Logged"> | string | null
33890
+ fetchAtBlock?: IntWithAggregatesFilter<"Logged"> | number
33891
+ caughtFromAddress?: StringWithAggregatesFilter<"Logged"> | string
33892
+ entityData?: JsonWithAggregatesFilter<"Logged">
33893
+ }
33894
+
32624
33895
  export type CampaignCreateInput = {
32625
33896
  id: string
32626
33897
  campaignId: string
@@ -34160,6 +35431,76 @@ export namespace Prisma {
34160
35431
  timestamp?: IntFieldUpdateOperationsInput | number
34161
35432
  }
34162
35433
 
35434
+ export type LoggedCreateInput = {
35435
+ id: string
35436
+ chainId: number
35437
+ type?: $Enums.LoggedEntityType
35438
+ address?: string | null
35439
+ fetchAtBlock: number
35440
+ caughtFromAddress: string
35441
+ entityData: JsonNullValueInput | InputJsonValue
35442
+ }
35443
+
35444
+ export type LoggedUncheckedCreateInput = {
35445
+ id: string
35446
+ chainId: number
35447
+ type?: $Enums.LoggedEntityType
35448
+ address?: string | null
35449
+ fetchAtBlock: number
35450
+ caughtFromAddress: string
35451
+ entityData: JsonNullValueInput | InputJsonValue
35452
+ }
35453
+
35454
+ export type LoggedUpdateInput = {
35455
+ id?: StringFieldUpdateOperationsInput | string
35456
+ chainId?: IntFieldUpdateOperationsInput | number
35457
+ type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
35458
+ address?: NullableStringFieldUpdateOperationsInput | string | null
35459
+ fetchAtBlock?: IntFieldUpdateOperationsInput | number
35460
+ caughtFromAddress?: StringFieldUpdateOperationsInput | string
35461
+ entityData?: JsonNullValueInput | InputJsonValue
35462
+ }
35463
+
35464
+ export type LoggedUncheckedUpdateInput = {
35465
+ id?: StringFieldUpdateOperationsInput | string
35466
+ chainId?: IntFieldUpdateOperationsInput | number
35467
+ type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
35468
+ address?: NullableStringFieldUpdateOperationsInput | string | null
35469
+ fetchAtBlock?: IntFieldUpdateOperationsInput | number
35470
+ caughtFromAddress?: StringFieldUpdateOperationsInput | string
35471
+ entityData?: JsonNullValueInput | InputJsonValue
35472
+ }
35473
+
35474
+ export type LoggedCreateManyInput = {
35475
+ id: string
35476
+ chainId: number
35477
+ type?: $Enums.LoggedEntityType
35478
+ address?: string | null
35479
+ fetchAtBlock: number
35480
+ caughtFromAddress: string
35481
+ entityData: JsonNullValueInput | InputJsonValue
35482
+ }
35483
+
35484
+ export type LoggedUpdateManyMutationInput = {
35485
+ id?: StringFieldUpdateOperationsInput | string
35486
+ chainId?: IntFieldUpdateOperationsInput | number
35487
+ type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
35488
+ address?: NullableStringFieldUpdateOperationsInput | string | null
35489
+ fetchAtBlock?: IntFieldUpdateOperationsInput | number
35490
+ caughtFromAddress?: StringFieldUpdateOperationsInput | string
35491
+ entityData?: JsonNullValueInput | InputJsonValue
35492
+ }
35493
+
35494
+ export type LoggedUncheckedUpdateManyInput = {
35495
+ id?: StringFieldUpdateOperationsInput | string
35496
+ chainId?: IntFieldUpdateOperationsInput | number
35497
+ type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
35498
+ address?: NullableStringFieldUpdateOperationsInput | string | null
35499
+ fetchAtBlock?: IntFieldUpdateOperationsInput | number
35500
+ caughtFromAddress?: StringFieldUpdateOperationsInput | string
35501
+ entityData?: JsonNullValueInput | InputJsonValue
35502
+ }
35503
+
34163
35504
  export type StringFilter<$PrismaModel = never> = {
34164
35505
  equals?: string | StringFieldRefInput<$PrismaModel>
34165
35506
  in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -35916,6 +37257,72 @@ export namespace Prisma {
35916
37257
  _max?: NestedDateTimeFilter<$PrismaModel>
35917
37258
  }
35918
37259
 
37260
+ export type EnumLoggedEntityTypeFilter<$PrismaModel = never> = {
37261
+ equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
37262
+ in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
37263
+ notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
37264
+ not?: NestedEnumLoggedEntityTypeFilter<$PrismaModel> | $Enums.LoggedEntityType
37265
+ }
37266
+
37267
+ export type LoggedOrderByRelevanceInput = {
37268
+ fields: LoggedOrderByRelevanceFieldEnum | LoggedOrderByRelevanceFieldEnum[]
37269
+ sort: SortOrder
37270
+ search: string
37271
+ }
37272
+
37273
+ export type LoggedChainIdAddressCompoundUniqueInput = {
37274
+ chainId: number
37275
+ address: string
37276
+ }
37277
+
37278
+ export type LoggedCountOrderByAggregateInput = {
37279
+ id?: SortOrder
37280
+ chainId?: SortOrder
37281
+ type?: SortOrder
37282
+ address?: SortOrder
37283
+ fetchAtBlock?: SortOrder
37284
+ caughtFromAddress?: SortOrder
37285
+ entityData?: SortOrder
37286
+ }
37287
+
37288
+ export type LoggedAvgOrderByAggregateInput = {
37289
+ chainId?: SortOrder
37290
+ fetchAtBlock?: SortOrder
37291
+ }
37292
+
37293
+ export type LoggedMaxOrderByAggregateInput = {
37294
+ id?: SortOrder
37295
+ chainId?: SortOrder
37296
+ type?: SortOrder
37297
+ address?: SortOrder
37298
+ fetchAtBlock?: SortOrder
37299
+ caughtFromAddress?: SortOrder
37300
+ }
37301
+
37302
+ export type LoggedMinOrderByAggregateInput = {
37303
+ id?: SortOrder
37304
+ chainId?: SortOrder
37305
+ type?: SortOrder
37306
+ address?: SortOrder
37307
+ fetchAtBlock?: SortOrder
37308
+ caughtFromAddress?: SortOrder
37309
+ }
37310
+
37311
+ export type LoggedSumOrderByAggregateInput = {
37312
+ chainId?: SortOrder
37313
+ fetchAtBlock?: SortOrder
37314
+ }
37315
+
37316
+ export type EnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel = never> = {
37317
+ equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
37318
+ in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
37319
+ notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
37320
+ not?: NestedEnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel> | $Enums.LoggedEntityType
37321
+ _count?: NestedIntFilter<$PrismaModel>
37322
+ _min?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
37323
+ _max?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
37324
+ }
37325
+
35919
37326
  export type ChainCreateNestedOneWithoutCampaignsInput = {
35920
37327
  create?: XOR<ChainCreateWithoutCampaignsInput, ChainUncheckedCreateWithoutCampaignsInput>
35921
37328
  connectOrCreate?: ChainCreateOrConnectWithoutCampaignsInput
@@ -38048,6 +39455,10 @@ export namespace Prisma {
38048
39455
  update?: XOR<XOR<TokenUpdateToOneWithWhereWithoutDumpToInput, TokenUpdateWithoutDumpToInput>, TokenUncheckedUpdateWithoutDumpToInput>
38049
39456
  }
38050
39457
 
39458
+ export type EnumLoggedEntityTypeFieldUpdateOperationsInput = {
39459
+ set?: $Enums.LoggedEntityType
39460
+ }
39461
+
38051
39462
  export type NestedStringFilter<$PrismaModel = never> = {
38052
39463
  equals?: string | StringFieldRefInput<$PrismaModel>
38053
39464
  in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -38467,6 +39878,23 @@ export namespace Prisma {
38467
39878
  _max?: NestedDateTimeFilter<$PrismaModel>
38468
39879
  }
38469
39880
 
39881
+ export type NestedEnumLoggedEntityTypeFilter<$PrismaModel = never> = {
39882
+ equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
39883
+ in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
39884
+ notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
39885
+ not?: NestedEnumLoggedEntityTypeFilter<$PrismaModel> | $Enums.LoggedEntityType
39886
+ }
39887
+
39888
+ export type NestedEnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel = never> = {
39889
+ equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
39890
+ in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
39891
+ notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
39892
+ not?: NestedEnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel> | $Enums.LoggedEntityType
39893
+ _count?: NestedIntFilter<$PrismaModel>
39894
+ _min?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
39895
+ _max?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
39896
+ }
39897
+
38470
39898
  export type ChainCreateWithoutCampaignsInput = {
38471
39899
  id: number
38472
39900
  name: string