@merkl/api 0.10.421 → 0.11.0

package/dist/database/api/.generated/index.d.ts

@@ -128,12 +128,27 @@ export type Blacklist = $Result.DefaultSelection<Prisma.$BlacklistPayload>
  * 
  */
 export type Dump = $Result.DefaultSelection<Prisma.$DumpPayload>
+/**
+ * Model Logged
+ * 
+ */
+export type Logged = $Result.DefaultSelection<Prisma.$LoggedPayload>
 
 /**
  * Enums
  */
 export namespace $Enums {
-  export const RunStatus: {
+  export const LoggedEntityType: {
+  UNKNOWN: 'UNKNOWN',
+  EULER_VAULT: 'EULER_VAULT',
+  UNISWAP_V4: 'UNISWAP_V4',
+  COMPOUND_v2: 'COMPOUND_v2'
+};
+
+export type LoggedEntityType = (typeof LoggedEntityType)[keyof typeof LoggedEntityType]
+
+
+export const RunStatus: {
   PROCESSING: 'PROCESSING',
   SUCCESS: 'SUCCESS',
   FAILED: 'FAILED',
@@ -235,6 +250,10 @@ export type PriceSourceMethod = (typeof PriceSourceMethod)[keyof typeof PriceSou
 
 }
 
+export type LoggedEntityType = $Enums.LoggedEntityType
+
+export const LoggedEntityType: typeof $Enums.LoggedEntityType
+
 export type RunStatus = $Enums.RunStatus
 
 export const RunStatus: typeof $Enums.RunStatus
@@ -621,6 +640,16 @@ export class PrismaClient<
     * ```
     */
   get dump(): Prisma.DumpDelegate<ExtArgs, ClientOptions>;
+
+  /**
+   * `prisma.logged`: Exposes CRUD operations for the **Logged** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Loggeds
+    * const loggeds = await prisma.logged.findMany()
+    * ```
+    */
+  get logged(): Prisma.LoggedDelegate<ExtArgs, ClientOptions>;
 }
 
 export namespace Prisma {
@@ -1083,7 +1112,8 @@ export namespace Prisma {
     MerklRoot: 'MerklRoot',
     PriceSource: 'PriceSource',
     Blacklist: 'Blacklist',
-    Dump: 'Dump'
+    Dump: 'Dump',
+    Logged: 'Logged'
   };
 
   export type ModelName = (typeof ModelName)[keyof typeof ModelName]
@@ -1099,7 +1129,7 @@ export namespace Prisma {
 
   export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
     meta: {
-      modelProps: "campaign" | "campaignStatus" | "campaignComputedValue" | "userComputedValue" | "chain" | "explorer" | "opportunity" | "protocol" | "token" | "aprRecord" | "aprBreakdown" | "tVLRecord" | "tVLBreakdown" | "dailyRewardsRecord" | "dailyRewardsBreakdown" | "user" | "creator" | "reward" | "rewardBreakdown" | "merklRoot" | "priceSource" | "blacklist" | "dump"
+      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"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -2805,6 +2835,80 @@ export namespace Prisma {
           }
         }
       }
+      Logged: {
+        payload: Prisma.$LoggedPayload<ExtArgs>
+        fields: Prisma.LoggedFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.LoggedFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.LoggedFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
+          }
+          findFirst: {
+            args: Prisma.LoggedFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.LoggedFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
+          }
+          findMany: {
+            args: Prisma.LoggedFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>[]
+          }
+          create: {
+            args: Prisma.LoggedCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
+          }
+          createMany: {
+            args: Prisma.LoggedCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          createManyAndReturn: {
+            args: Prisma.LoggedCreateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>[]
+          }
+          delete: {
+            args: Prisma.LoggedDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
+          }
+          update: {
+            args: Prisma.LoggedUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
+          }
+          deleteMany: {
+            args: Prisma.LoggedDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.LoggedUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateManyAndReturn: {
+            args: Prisma.LoggedUpdateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>[]
+          }
+          upsert: {
+            args: Prisma.LoggedUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$LoggedPayload>
+          }
+          aggregate: {
+            args: Prisma.LoggedAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateLogged>
+          }
+          groupBy: {
+            args: Prisma.LoggedGroupByArgs<ExtArgs>
+            result: $Utils.Optional<LoggedGroupByOutputType>[]
+          }
+          count: {
+            args: Prisma.LoggedCountArgs<ExtArgs>
+            result: $Utils.Optional<LoggedCountAggregateOutputType> | number
+          }
+        }
+      }
     }
   } & {
     other: {
@@ -2912,6 +3016,7 @@ export namespace Prisma {
     priceSource?: PriceSourceOmit
     blacklist?: BlacklistOmit
     dump?: DumpOmit
+    logged?: LoggedOmit
   }
 
   /* Types for Logging */
@@ -29830,439 +29935,1503 @@ export namespace Prisma {
 
 
   /**
-   * Fields of the Dump model
+   * Fields of the Dump model
+   */ 
+  interface DumpFieldRefs {
+    readonly id: FieldRef<"Dump", 'String'>
+    readonly chainId: FieldRef<"Dump", 'Int'>
+    readonly fromTokenId: FieldRef<"Dump", 'String'>
+    readonly toTokenId: FieldRef<"Dump", 'String'>
+    readonly multisig: FieldRef<"Dump", 'String'>
+    readonly recipient: FieldRef<"Dump", 'String'>
+    readonly amountIn: FieldRef<"Dump", 'String'>
+    readonly amountOut: FieldRef<"Dump", 'String'>
+    readonly datetime: FieldRef<"Dump", 'DateTime'>
+    readonly timestamp: FieldRef<"Dump", 'Int'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * Dump findUnique
+   */
+  export type DumpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * Filter, which Dump to fetch.
+     */
+    where: DumpWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump findUniqueOrThrow
+   */
+  export type DumpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * Filter, which Dump to fetch.
+     */
+    where: DumpWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump findFirst
+   */
+  export type DumpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * Filter, which Dump to fetch.
+     */
+    where?: DumpWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Dumps to fetch.
+     */
+    orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for Dumps.
+     */
+    cursor?: DumpWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Dumps from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Dumps.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of Dumps.
+     */
+    distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump findFirstOrThrow
+   */
+  export type DumpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * Filter, which Dump to fetch.
+     */
+    where?: DumpWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Dumps to fetch.
+     */
+    orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for Dumps.
+     */
+    cursor?: DumpWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Dumps from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Dumps.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of Dumps.
+     */
+    distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump findMany
+   */
+  export type DumpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * Filter, which Dumps to fetch.
+     */
+    where?: DumpWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Dumps to fetch.
+     */
+    orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing Dumps.
+     */
+    cursor?: DumpWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Dumps from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Dumps.
+     */
+    skip?: number
+    distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump create
+   */
+  export type DumpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * The data needed to create a Dump.
+     */
+    data: XOR<DumpCreateInput, DumpUncheckedCreateInput>
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump createMany
+   */
+  export type DumpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many Dumps.
+     */
+    data: DumpCreateManyInput | DumpCreateManyInput[]
+    skipDuplicates?: boolean
+  }
+
+  /**
+   * Dump createManyAndReturn
+   */
+  export type DumpCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelectCreateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * The data used to create many Dumps.
+     */
+    data: DumpCreateManyInput | DumpCreateManyInput[]
+    skipDuplicates?: boolean
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpIncludeCreateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * Dump update
+   */
+  export type DumpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * The data needed to update a Dump.
+     */
+    data: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
+    /**
+     * Choose, which Dump to update.
+     */
+    where: DumpWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump updateMany
+   */
+  export type DumpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update Dumps.
+     */
+    data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
+    /**
+     * Filter which Dumps to update
+     */
+    where?: DumpWhereInput
+    /**
+     * Limit how many Dumps to update.
+     */
+    limit?: number
+  }
+
+  /**
+   * Dump updateManyAndReturn
+   */
+  export type DumpUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelectUpdateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * The data used to update Dumps.
+     */
+    data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
+    /**
+     * Filter which Dumps to update
+     */
+    where?: DumpWhereInput
+    /**
+     * Limit how many Dumps to update.
+     */
+    limit?: number
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpIncludeUpdateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * Dump upsert
+   */
+  export type DumpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * The filter to search for the Dump to update in case it exists.
+     */
+    where: DumpWhereUniqueInput
+    /**
+     * In case the Dump found by the `where` argument doesn't exist, create a new Dump with this data.
+     */
+    create: XOR<DumpCreateInput, DumpUncheckedCreateInput>
+    /**
+     * In case the Dump was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump delete
+   */
+  export type DumpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+    /**
+     * Filter which Dump to delete.
+     */
+    where: DumpWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Dump deleteMany
+   */
+  export type DumpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which Dumps to delete
+     */
+    where?: DumpWhereInput
+    /**
+     * Limit how many Dumps to delete.
+     */
+    limit?: number
+  }
+
+  /**
+   * Dump without action
+   */
+  export type DumpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Dump
+     */
+    select?: DumpSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the Dump
+     */
+    omit?: DumpOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: DumpInclude<ExtArgs> | null
+  }
+
+
+  /**
+   * Model Logged
+   */
+
+  export type AggregateLogged = {
+    _count: LoggedCountAggregateOutputType | null
+    _avg: LoggedAvgAggregateOutputType | null
+    _sum: LoggedSumAggregateOutputType | null
+    _min: LoggedMinAggregateOutputType | null
+    _max: LoggedMaxAggregateOutputType | null
+  }
+
+  export type LoggedAvgAggregateOutputType = {
+    chainId: number | null
+    fetchAtBlock: number | null
+  }
+
+  export type LoggedSumAggregateOutputType = {
+    chainId: number | null
+    fetchAtBlock: number | null
+  }
+
+  export type LoggedMinAggregateOutputType = {
+    id: string | null
+    chainId: number | null
+    type: $Enums.LoggedEntityType | null
+    address: string | null
+    fetchAtBlock: number | null
+    caughtFromAddress: string | null
+  }
+
+  export type LoggedMaxAggregateOutputType = {
+    id: string | null
+    chainId: number | null
+    type: $Enums.LoggedEntityType | null
+    address: string | null
+    fetchAtBlock: number | null
+    caughtFromAddress: string | null
+  }
+
+  export type LoggedCountAggregateOutputType = {
+    id: number
+    chainId: number
+    type: number
+    address: number
+    fetchAtBlock: number
+    caughtFromAddress: number
+    entityData: number
+    _all: number
+  }
+
+
+  export type LoggedAvgAggregateInputType = {
+    chainId?: true
+    fetchAtBlock?: true
+  }
+
+  export type LoggedSumAggregateInputType = {
+    chainId?: true
+    fetchAtBlock?: true
+  }
+
+  export type LoggedMinAggregateInputType = {
+    id?: true
+    chainId?: true
+    type?: true
+    address?: true
+    fetchAtBlock?: true
+    caughtFromAddress?: true
+  }
+
+  export type LoggedMaxAggregateInputType = {
+    id?: true
+    chainId?: true
+    type?: true
+    address?: true
+    fetchAtBlock?: true
+    caughtFromAddress?: true
+  }
+
+  export type LoggedCountAggregateInputType = {
+    id?: true
+    chainId?: true
+    type?: true
+    address?: true
+    fetchAtBlock?: true
+    caughtFromAddress?: true
+    entityData?: true
+    _all?: true
+  }
+
+  export type LoggedAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which Logged to aggregate.
+     */
+    where?: LoggedWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Loggeds to fetch.
+     */
+    orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: LoggedWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Loggeds from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` Loggeds.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned Loggeds
+    **/
+    _count?: true | LoggedCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to average
+    **/
+    _avg?: LoggedAvgAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to sum
+    **/
+    _sum?: LoggedSumAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: LoggedMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: LoggedMaxAggregateInputType
+  }
+
+  export type GetLoggedAggregateType<T extends LoggedAggregateArgs> = {
+        [P in keyof T & keyof AggregateLogged]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateLogged[P]>
+      : GetScalarType<T[P], AggregateLogged[P]>
+  }
+
+
+
+
+  export type LoggedGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: LoggedWhereInput
+    orderBy?: LoggedOrderByWithAggregationInput | LoggedOrderByWithAggregationInput[]
+    by: LoggedScalarFieldEnum[] | LoggedScalarFieldEnum
+    having?: LoggedScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: LoggedCountAggregateInputType | true
+    _avg?: LoggedAvgAggregateInputType
+    _sum?: LoggedSumAggregateInputType
+    _min?: LoggedMinAggregateInputType
+    _max?: LoggedMaxAggregateInputType
+  }
+
+  export type LoggedGroupByOutputType = {
+    id: string
+    chainId: number
+    type: $Enums.LoggedEntityType
+    address: string | null
+    fetchAtBlock: number
+    caughtFromAddress: string
+    entityData: JsonValue
+    _count: LoggedCountAggregateOutputType | null
+    _avg: LoggedAvgAggregateOutputType | null
+    _sum: LoggedSumAggregateOutputType | null
+    _min: LoggedMinAggregateOutputType | null
+    _max: LoggedMaxAggregateOutputType | null
+  }
+
+  type GetLoggedGroupByPayload<T extends LoggedGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<LoggedGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof LoggedGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], LoggedGroupByOutputType[P]>
+            : GetScalarType<T[P], LoggedGroupByOutputType[P]>
+        }
+      >
+    >
+
+
+  export type LoggedSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    chainId?: boolean
+    type?: boolean
+    address?: boolean
+    fetchAtBlock?: boolean
+    caughtFromAddress?: boolean
+    entityData?: boolean
+  }, ExtArgs["result"]["logged"]>
+
+  export type LoggedSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    chainId?: boolean
+    type?: boolean
+    address?: boolean
+    fetchAtBlock?: boolean
+    caughtFromAddress?: boolean
+    entityData?: boolean
+  }, ExtArgs["result"]["logged"]>
+
+  export type LoggedSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    chainId?: boolean
+    type?: boolean
+    address?: boolean
+    fetchAtBlock?: boolean
+    caughtFromAddress?: boolean
+    entityData?: boolean
+  }, ExtArgs["result"]["logged"]>
+
+  export type LoggedSelectScalar = {
+    id?: boolean
+    chainId?: boolean
+    type?: boolean
+    address?: boolean
+    fetchAtBlock?: boolean
+    caughtFromAddress?: boolean
+    entityData?: boolean
+  }
+
+  export type LoggedOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "chainId" | "type" | "address" | "fetchAtBlock" | "caughtFromAddress" | "entityData", ExtArgs["result"]["logged"]>
+
+  export type $LoggedPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "Logged"
+    objects: {}
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      chainId: number
+      type: $Enums.LoggedEntityType
+      address: string | null
+      fetchAtBlock: number
+      caughtFromAddress: string
+      entityData: Prisma.JsonValue
+    }, ExtArgs["result"]["logged"]>
+    composites: {}
+  }
+
+  type LoggedGetPayload<S extends boolean | null | undefined | LoggedDefaultArgs> = $Result.GetResult<Prisma.$LoggedPayload, S>
+
+  type LoggedCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
+    Omit<LoggedFindManyArgs, 'select' | 'include' | 'distinct' | 'omit' | 'relationLoadStrategy'> & {
+      select?: LoggedCountAggregateInputType | true
+    }
+
+  export interface LoggedDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Logged'], meta: { name: 'Logged' } }
+    /**
+     * Find zero or one Logged that matches the filter.
+     * @param {LoggedFindUniqueArgs} args - Arguments to find a Logged
+     * @example
+     * // Get one Logged
+     * const logged = await prisma.logged.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends LoggedFindUniqueArgs>(args: SelectSubset<T, LoggedFindUniqueArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findUnique", ClientOptions> | null, null, ExtArgs, ClientOptions>
+
+    /**
+     * Find one Logged that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {LoggedFindUniqueOrThrowArgs} args - Arguments to find a Logged
+     * @example
+     * // Get one Logged
+     * const logged = await prisma.logged.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends LoggedFindUniqueOrThrowArgs>(args: SelectSubset<T, LoggedFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findUniqueOrThrow", ClientOptions>, never, ExtArgs, ClientOptions>
+
+    /**
+     * Find the first Logged that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedFindFirstArgs} args - Arguments to find a Logged
+     * @example
+     * // Get one Logged
+     * const logged = await prisma.logged.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends LoggedFindFirstArgs>(args?: SelectSubset<T, LoggedFindFirstArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findFirst", ClientOptions> | null, null, ExtArgs, ClientOptions>
+
+    /**
+     * Find the first Logged that matches the filter or
+     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedFindFirstOrThrowArgs} args - Arguments to find a Logged
+     * @example
+     * // Get one Logged
+     * const logged = await prisma.logged.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends LoggedFindFirstOrThrowArgs>(args?: SelectSubset<T, LoggedFindFirstOrThrowArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findFirstOrThrow", ClientOptions>, never, ExtArgs, ClientOptions>
+
+    /**
+     * Find zero or more Loggeds that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Loggeds
+     * const loggeds = await prisma.logged.findMany()
+     * 
+     * // Get first 10 Loggeds
+     * const loggeds = await prisma.logged.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const loggedWithIdOnly = await prisma.logged.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends LoggedFindManyArgs>(args?: SelectSubset<T, LoggedFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "findMany", ClientOptions>>
+
+    /**
+     * Create a Logged.
+     * @param {LoggedCreateArgs} args - Arguments to create a Logged.
+     * @example
+     * // Create one Logged
+     * const Logged = await prisma.logged.create({
+     *   data: {
+     *     // ... data to create a Logged
+     *   }
+     * })
+     * 
+     */
+    create<T extends LoggedCreateArgs>(args: SelectSubset<T, LoggedCreateArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "create", ClientOptions>, never, ExtArgs, ClientOptions>
+
+    /**
+     * Create many Loggeds.
+     * @param {LoggedCreateManyArgs} args - Arguments to create many Loggeds.
+     * @example
+     * // Create many Loggeds
+     * const logged = await prisma.logged.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends LoggedCreateManyArgs>(args?: SelectSubset<T, LoggedCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many Loggeds and returns the data saved in the database.
+     * @param {LoggedCreateManyAndReturnArgs} args - Arguments to create many Loggeds.
+     * @example
+     * // Create many Loggeds
+     * const logged = await prisma.logged.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many Loggeds and only return the `id`
+     * const loggedWithIdOnly = await prisma.logged.createManyAndReturn({
+     *   select: { id: true },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * 
+     */
+    createManyAndReturn<T extends LoggedCreateManyAndReturnArgs>(args?: SelectSubset<T, LoggedCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "createManyAndReturn", ClientOptions>>
+
+    /**
+     * Delete a Logged.
+     * @param {LoggedDeleteArgs} args - Arguments to delete one Logged.
+     * @example
+     * // Delete one Logged
+     * const Logged = await prisma.logged.delete({
+     *   where: {
+     *     // ... filter to delete one Logged
+     *   }
+     * })
+     * 
+     */
+    delete<T extends LoggedDeleteArgs>(args: SelectSubset<T, LoggedDeleteArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "delete", ClientOptions>, never, ExtArgs, ClientOptions>
+
+    /**
+     * Update one Logged.
+     * @param {LoggedUpdateArgs} args - Arguments to update one Logged.
+     * @example
+     * // Update one Logged
+     * const logged = await prisma.logged.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends LoggedUpdateArgs>(args: SelectSubset<T, LoggedUpdateArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "update", ClientOptions>, never, ExtArgs, ClientOptions>
+
+    /**
+     * Delete zero or more Loggeds.
+     * @param {LoggedDeleteManyArgs} args - Arguments to filter Loggeds to delete.
+     * @example
+     * // Delete a few Loggeds
+     * const { count } = await prisma.logged.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends LoggedDeleteManyArgs>(args?: SelectSubset<T, LoggedDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more Loggeds.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many Loggeds
+     * const logged = await prisma.logged.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends LoggedUpdateManyArgs>(args: SelectSubset<T, LoggedUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more Loggeds and returns the data updated in the database.
+     * @param {LoggedUpdateManyAndReturnArgs} args - Arguments to update many Loggeds.
+     * @example
+     * // Update many Loggeds
+     * const logged = await prisma.logged.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Update zero or more Loggeds and only return the `id`
+     * const loggedWithIdOnly = await prisma.logged.updateManyAndReturn({
+     *   select: { id: true },
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * 
+     */
+    updateManyAndReturn<T extends LoggedUpdateManyAndReturnArgs>(args: SelectSubset<T, LoggedUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "updateManyAndReturn", ClientOptions>>
+
+    /**
+     * Create or update one Logged.
+     * @param {LoggedUpsertArgs} args - Arguments to update or create a Logged.
+     * @example
+     * // Update or create a Logged
+     * const logged = await prisma.logged.upsert({
+     *   create: {
+     *     // ... data to create a Logged
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the Logged we want to update
+     *   }
+     * })
+     */
+    upsert<T extends LoggedUpsertArgs>(args: SelectSubset<T, LoggedUpsertArgs<ExtArgs>>): Prisma__LoggedClient<$Result.GetResult<Prisma.$LoggedPayload<ExtArgs>, T, "upsert", ClientOptions>, never, ExtArgs, ClientOptions>
+
+
+    /**
+     * Count the number of Loggeds.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedCountArgs} args - Arguments to filter Loggeds to count.
+     * @example
+     * // Count the number of Loggeds
+     * const count = await prisma.logged.count({
+     *   where: {
+     *     // ... the filter for the Loggeds we want to count
+     *   }
+     * })
+    **/
+    count<T extends LoggedCountArgs>(
+      args?: Subset<T, LoggedCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], LoggedCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a Logged.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+     * @example
+     * // Ordered by age ascending
+     * // Where email contains prisma.io
+     * // Limited to the 10 users
+     * const aggregations = await prisma.user.aggregate({
+     *   _avg: {
+     *     age: true,
+     *   },
+     *   where: {
+     *     email: {
+     *       contains: "prisma.io",
+     *     },
+     *   },
+     *   orderBy: {
+     *     age: "asc",
+     *   },
+     *   take: 10,
+     * })
+    **/
+    aggregate<T extends LoggedAggregateArgs>(args: Subset<T, LoggedAggregateArgs>): Prisma.PrismaPromise<GetLoggedAggregateType<T>>
+
+    /**
+     * Group by Logged.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {LoggedGroupByArgs} args - Group by arguments.
+     * @example
+     * // Group by city, order by createdAt, get count
+     * const result = await prisma.user.groupBy({
+     *   by: ['city', 'createdAt'],
+     *   orderBy: {
+     *     createdAt: true
+     *   },
+     *   _count: {
+     *     _all: true
+     *   },
+     * })
+     * 
+    **/
+    groupBy<
+      T extends LoggedGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: LoggedGroupByArgs['orderBy'] }
+        : { orderBy?: LoggedGroupByArgs['orderBy'] },
+      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
+      ByFields extends MaybeTupleToUnion<T['by']>,
+      ByValid extends Has<ByFields, OrderFields>,
+      HavingFields extends GetHavingFields<T['having']>,
+      HavingValid extends Has<ByFields, HavingFields>,
+      ByEmpty extends T['by'] extends never[] ? True : False,
+      InputErrors extends ByEmpty extends True
+      ? `Error: "by" must not be empty.`
+      : HavingValid extends False
+      ? {
+          [P in HavingFields]: P extends ByFields
+            ? never
+            : P extends string
+            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+            : [
+                Error,
+                'Field ',
+                P,
+                ` in "having" needs to be provided in "by"`,
+              ]
+        }[HavingFields]
+      : 'take' extends Keys<T>
+      ? 'orderBy' extends Keys<T>
+        ? ByValid extends True
+          ? {}
+          : {
+              [P in OrderFields]: P extends ByFields
+                ? never
+                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+            }[OrderFields]
+        : 'Error: If you provide "take", you also need to provide "orderBy"'
+      : 'skip' extends Keys<T>
+      ? 'orderBy' extends Keys<T>
+        ? ByValid extends True
+          ? {}
+          : {
+              [P in OrderFields]: P extends ByFields
+                ? never
+                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+            }[OrderFields]
+        : 'Error: If you provide "skip", you also need to provide "orderBy"'
+      : ByValid extends True
+      ? {}
+      : {
+          [P in OrderFields]: P extends ByFields
+            ? never
+            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+        }[OrderFields]
+    >(args: SubsetIntersection<T, LoggedGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLoggedGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the Logged model
+   */
+  readonly fields: LoggedFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for Logged.
+   * Why is this prefixed with `Prisma__`?
+   * Because we want to prevent naming conflicts as mentioned in
+   * https://github.com/prisma/prisma-client-js/issues/707
+   */
+  export interface Prisma__LoggedClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    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>
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
+  }
+
+
+
+
+  /**
+   * Fields of the Logged model
    */ 
-  interface DumpFieldRefs {
-    readonly id: FieldRef<"Dump", 'String'>
-    readonly chainId: FieldRef<"Dump", 'Int'>
-    readonly fromTokenId: FieldRef<"Dump", 'String'>
-    readonly toTokenId: FieldRef<"Dump", 'String'>
-    readonly multisig: FieldRef<"Dump", 'String'>
-    readonly recipient: FieldRef<"Dump", 'String'>
-    readonly amountIn: FieldRef<"Dump", 'String'>
-    readonly amountOut: FieldRef<"Dump", 'String'>
-    readonly datetime: FieldRef<"Dump", 'DateTime'>
-    readonly timestamp: FieldRef<"Dump", 'Int'>
+  interface LoggedFieldRefs {
+    readonly id: FieldRef<"Logged", 'String'>
+    readonly chainId: FieldRef<"Logged", 'Int'>
+    readonly type: FieldRef<"Logged", 'LoggedEntityType'>
+    readonly address: FieldRef<"Logged", 'String'>
+    readonly fetchAtBlock: FieldRef<"Logged", 'Int'>
+    readonly caughtFromAddress: FieldRef<"Logged", 'String'>
+    readonly entityData: FieldRef<"Logged", 'Json'>
   }
     
 
   // Custom InputTypes
   /**
-   * Dump findUnique
+   * Logged findUnique
    */
-  export type DumpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the Dump
-     */
-    select?: DumpSelect<ExtArgs> | null
+  export type LoggedFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Omit specific fields from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * Filter, which Dump to fetch.
+     * Filter, which Logged to fetch.
      */
-    where: DumpWhereUniqueInput
+    where: LoggedWhereUniqueInput
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump findUniqueOrThrow
+   * Logged findUniqueOrThrow
    */
-  export type DumpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the Dump
-     */
-    select?: DumpSelect<ExtArgs> | null
+  export type LoggedFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Omit specific fields from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * Filter, which Dump to fetch.
+     * Filter, which Logged to fetch.
      */
-    where: DumpWhereUniqueInput
+    where: LoggedWhereUniqueInput
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump findFirst
+   * Logged findFirst
    */
-  export type DumpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    select?: DumpSelect<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Omit specific fields from the Dump
-     */
-    omit?: DumpOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * Filter, which Dump to fetch.
+     * Filter, which Logged to fetch.
      */
-    where?: DumpWhereInput
+    where?: LoggedWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of Dumps to fetch.
+     * Determine the order of Loggeds to fetch.
      */
-    orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
+    orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
-     * Sets the position for searching for Dumps.
+     * Sets the position for searching for Loggeds.
      */
-    cursor?: DumpWhereUniqueInput
+    cursor?: LoggedWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` Dumps from the position of the cursor.
+     * Take `±n` Loggeds from the position of the cursor.
      */
     take?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Skip the first `n` Dumps.
+     * Skip the first `n` Loggeds.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
      * 
-     * Filter by unique combinations of Dumps.
+     * Filter by unique combinations of Loggeds.
      */
-    distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
+    distinct?: LoggedScalarFieldEnum | LoggedScalarFieldEnum[]
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump findFirstOrThrow
+   * Logged findFirstOrThrow
    */
-  export type DumpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    select?: DumpSelect<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Omit specific fields from the Dump
-     */
-    omit?: DumpOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * Filter, which Dump to fetch.
+     * Filter, which Logged to fetch.
      */
-    where?: DumpWhereInput
+    where?: LoggedWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of Dumps to fetch.
+     * Determine the order of Loggeds to fetch.
      */
-    orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
+    orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
-     * Sets the position for searching for Dumps.
+     * Sets the position for searching for Loggeds.
      */
-    cursor?: DumpWhereUniqueInput
+    cursor?: LoggedWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` Dumps from the position of the cursor.
+     * Take `±n` Loggeds from the position of the cursor.
      */
     take?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Skip the first `n` Dumps.
+     * Skip the first `n` Loggeds.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
      * 
-     * Filter by unique combinations of Dumps.
+     * Filter by unique combinations of Loggeds.
      */
-    distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
+    distinct?: LoggedScalarFieldEnum | LoggedScalarFieldEnum[]
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump findMany
+   * Logged findMany
    */
-  export type DumpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    select?: DumpSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the Dump
-     */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * Filter, which Dumps to fetch.
+     * Filter, which Loggeds to fetch.
      */
-    where?: DumpWhereInput
+    where?: LoggedWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of Dumps to fetch.
+     * Determine the order of Loggeds to fetch.
      */
-    orderBy?: DumpOrderByWithRelationInput | DumpOrderByWithRelationInput[]
+    orderBy?: LoggedOrderByWithRelationInput | LoggedOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
-     * Sets the position for listing Dumps.
+     * Sets the position for listing Loggeds.
      */
-    cursor?: DumpWhereUniqueInput
+    cursor?: LoggedWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` Dumps from the position of the cursor.
+     * Take `±n` Loggeds from the position of the cursor.
      */
     take?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Skip the first `n` Dumps.
+     * Skip the first `n` Loggeds.
      */
     skip?: number
-    distinct?: DumpScalarFieldEnum | DumpScalarFieldEnum[]
+    distinct?: LoggedScalarFieldEnum | LoggedScalarFieldEnum[]
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump create
+   * Logged create
    */
-  export type DumpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    select?: DumpSelect<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Omit specific fields from the Dump
-     */
-    omit?: DumpOmit<ExtArgs> | null
-    /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * The data needed to create a Dump.
+     * The data needed to create a Logged.
      */
-    data: XOR<DumpCreateInput, DumpUncheckedCreateInput>
+    data: XOR<LoggedCreateInput, LoggedUncheckedCreateInput>
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump createMany
+   * Logged createMany
    */
-  export type DumpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * The data used to create many Dumps.
+     * The data used to create many Loggeds.
      */
-    data: DumpCreateManyInput | DumpCreateManyInput[]
+    data: LoggedCreateManyInput | LoggedCreateManyInput[]
     skipDuplicates?: boolean
   }
 
   /**
-   * Dump createManyAndReturn
+   * Logged createManyAndReturn
    */
-  export type DumpCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    select?: DumpSelectCreateManyAndReturn<ExtArgs> | null
+    select?: LoggedSelectCreateManyAndReturn<ExtArgs> | null
     /**
-     * Omit specific fields from the Dump
+     * Omit specific fields from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * The data used to create many Dumps.
+     * The data used to create many Loggeds.
      */
-    data: DumpCreateManyInput | DumpCreateManyInput[]
+    data: LoggedCreateManyInput | LoggedCreateManyInput[]
     skipDuplicates?: boolean
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: DumpIncludeCreateManyAndReturn<ExtArgs> | null
   }
 
   /**
-   * Dump update
+   * Logged update
    */
-  export type DumpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the Dump
-     */
-    select?: DumpSelect<ExtArgs> | null
+  export type LoggedUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Omit specific fields from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * The data needed to update a Dump.
+     * The data needed to update a Logged.
      */
-    data: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
+    data: XOR<LoggedUpdateInput, LoggedUncheckedUpdateInput>
     /**
-     * Choose, which Dump to update.
+     * Choose, which Logged to update.
      */
-    where: DumpWhereUniqueInput
+    where: LoggedWhereUniqueInput
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump updateMany
+   * Logged updateMany
    */
-  export type DumpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * The data used to update Dumps.
+     * The data used to update Loggeds.
      */
-    data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
+    data: XOR<LoggedUpdateManyMutationInput, LoggedUncheckedUpdateManyInput>
     /**
-     * Filter which Dumps to update
+     * Filter which Loggeds to update
      */
-    where?: DumpWhereInput
+    where?: LoggedWhereInput
     /**
-     * Limit how many Dumps to update.
+     * Limit how many Loggeds to update.
      */
     limit?: number
   }
 
   /**
-   * Dump updateManyAndReturn
+   * Logged updateManyAndReturn
    */
-  export type DumpUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    select?: DumpSelectUpdateManyAndReturn<ExtArgs> | null
+    select?: LoggedSelectUpdateManyAndReturn<ExtArgs> | null
     /**
-     * Omit specific fields from the Dump
+     * Omit specific fields from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * The data used to update Dumps.
+     * The data used to update Loggeds.
      */
-    data: XOR<DumpUpdateManyMutationInput, DumpUncheckedUpdateManyInput>
+    data: XOR<LoggedUpdateManyMutationInput, LoggedUncheckedUpdateManyInput>
     /**
-     * Filter which Dumps to update
+     * Filter which Loggeds to update
      */
-    where?: DumpWhereInput
+    where?: LoggedWhereInput
     /**
-     * Limit how many Dumps to update.
+     * Limit how many Loggeds to update.
      */
     limit?: number
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: DumpIncludeUpdateManyAndReturn<ExtArgs> | null
   }
 
   /**
-   * Dump upsert
+   * Logged upsert
    */
-  export type DumpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the Dump
-     */
-    select?: DumpSelect<ExtArgs> | null
+  export type LoggedUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Omit specific fields from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * The filter to search for the Dump to update in case it exists.
+     * The filter to search for the Logged to update in case it exists.
      */
-    where: DumpWhereUniqueInput
+    where: LoggedWhereUniqueInput
     /**
-     * In case the Dump found by the `where` argument doesn't exist, create a new Dump with this data.
+     * In case the Logged found by the `where` argument doesn't exist, create a new Logged with this data.
      */
-    create: XOR<DumpCreateInput, DumpUncheckedCreateInput>
+    create: XOR<LoggedCreateInput, LoggedUncheckedCreateInput>
     /**
-     * In case the Dump was found with the provided `where` argument, update it with this data.
+     * In case the Logged was found with the provided `where` argument, update it with this data.
      */
-    update: XOR<DumpUpdateInput, DumpUncheckedUpdateInput>
+    update: XOR<LoggedUpdateInput, LoggedUncheckedUpdateInput>
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump delete
+   * Logged delete
    */
-  export type DumpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Dump
-     */
-    select?: DumpSelect<ExtArgs> | null
-    /**
-     * Omit specific fields from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
     /**
-     * Filter which Dump to delete.
+     * Filter which Logged to delete.
      */
-    where: DumpWhereUniqueInput
+    where: LoggedWhereUniqueInput
     relationLoadStrategy?: RelationLoadStrategy
   }
 
   /**
-   * Dump deleteMany
+   * Logged deleteMany
    */
-  export type DumpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type LoggedDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Filter which Dumps to delete
+     * Filter which Loggeds to delete
      */
-    where?: DumpWhereInput
+    where?: LoggedWhereInput
     /**
-     * Limit how many Dumps to delete.
+     * Limit how many Loggeds to delete.
      */
     limit?: number
   }
 
   /**
-   * Dump without action
+   * Logged without action
    */
-  export type DumpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the Dump
-     */
-    select?: DumpSelect<ExtArgs> | null
+  export type LoggedDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Omit specific fields from the Dump
+     * Select specific fields to fetch from the Logged
      */
-    omit?: DumpOmit<ExtArgs> | null
+    select?: LoggedSelect<ExtArgs> | null
     /**
-     * Choose, which related nodes to fetch as well
+     * Omit specific fields from the Logged
      */
-    include?: DumpInclude<ExtArgs> | null
+    omit?: LoggedOmit<ExtArgs> | null
   }
 
 
@@ -30563,6 +31732,19 @@ export namespace Prisma {
   export type DumpScalarFieldEnum = (typeof DumpScalarFieldEnum)[keyof typeof DumpScalarFieldEnum]
 
 
+  export const LoggedScalarFieldEnum: {
+    id: 'id',
+    chainId: 'chainId',
+    type: 'type',
+    address: 'address',
+    fetchAtBlock: 'fetchAtBlock',
+    caughtFromAddress: 'caughtFromAddress',
+    entityData: 'entityData'
+  };
+
+  export type LoggedScalarFieldEnum = (typeof LoggedScalarFieldEnum)[keyof typeof LoggedScalarFieldEnum]
+
+
   export const SortOrder: {
     asc: 'asc',
     desc: 'desc'
@@ -30828,6 +32010,15 @@ export namespace Prisma {
   export type DumpOrderByRelevanceFieldEnum = (typeof DumpOrderByRelevanceFieldEnum)[keyof typeof DumpOrderByRelevanceFieldEnum]
 
 
+  export const LoggedOrderByRelevanceFieldEnum: {
+    id: 'id',
+    address: 'address',
+    caughtFromAddress: 'caughtFromAddress'
+  };
+
+  export type LoggedOrderByRelevanceFieldEnum = (typeof LoggedOrderByRelevanceFieldEnum)[keyof typeof LoggedOrderByRelevanceFieldEnum]
+
+
   /**
    * Field references 
    */
@@ -31027,6 +32218,20 @@ export namespace Prisma {
    */
   export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
     
+
+
+  /**
+   * Reference to a field of type 'LoggedEntityType'
+   */
+  export type EnumLoggedEntityTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LoggedEntityType'>
+    
+
+
+  /**
+   * Reference to a field of type 'LoggedEntityType[]'
+   */
+  export type ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LoggedEntityType[]'>
+    
   /**
    * Deep Input Types
    */
@@ -32621,6 +33826,72 @@ export namespace Prisma {
     timestamp?: IntWithAggregatesFilter<"Dump"> | number
   }
 
+  export type LoggedWhereInput = {
+    AND?: LoggedWhereInput | LoggedWhereInput[]
+    OR?: LoggedWhereInput[]
+    NOT?: LoggedWhereInput | LoggedWhereInput[]
+    id?: StringFilter<"Logged"> | string
+    chainId?: IntFilter<"Logged"> | number
+    type?: EnumLoggedEntityTypeFilter<"Logged"> | $Enums.LoggedEntityType
+    address?: StringNullableFilter<"Logged"> | string | null
+    fetchAtBlock?: IntFilter<"Logged"> | number
+    caughtFromAddress?: StringFilter<"Logged"> | string
+    entityData?: JsonFilter<"Logged">
+  }
+
+  export type LoggedOrderByWithRelationInput = {
+    id?: SortOrder
+    chainId?: SortOrder
+    type?: SortOrder
+    address?: SortOrderInput | SortOrder
+    fetchAtBlock?: SortOrder
+    caughtFromAddress?: SortOrder
+    entityData?: SortOrder
+    _relevance?: LoggedOrderByRelevanceInput
+  }
+
+  export type LoggedWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    chainId_address?: LoggedChainIdAddressCompoundUniqueInput
+    AND?: LoggedWhereInput | LoggedWhereInput[]
+    OR?: LoggedWhereInput[]
+    NOT?: LoggedWhereInput | LoggedWhereInput[]
+    chainId?: IntFilter<"Logged"> | number
+    type?: EnumLoggedEntityTypeFilter<"Logged"> | $Enums.LoggedEntityType
+    address?: StringNullableFilter<"Logged"> | string | null
+    fetchAtBlock?: IntFilter<"Logged"> | number
+    caughtFromAddress?: StringFilter<"Logged"> | string
+    entityData?: JsonFilter<"Logged">
+  }, "id" | "chainId_address">
+
+  export type LoggedOrderByWithAggregationInput = {
+    id?: SortOrder
+    chainId?: SortOrder
+    type?: SortOrder
+    address?: SortOrderInput | SortOrder
+    fetchAtBlock?: SortOrder
+    caughtFromAddress?: SortOrder
+    entityData?: SortOrder
+    _count?: LoggedCountOrderByAggregateInput
+    _avg?: LoggedAvgOrderByAggregateInput
+    _max?: LoggedMaxOrderByAggregateInput
+    _min?: LoggedMinOrderByAggregateInput
+    _sum?: LoggedSumOrderByAggregateInput
+  }
+
+  export type LoggedScalarWhereWithAggregatesInput = {
+    AND?: LoggedScalarWhereWithAggregatesInput | LoggedScalarWhereWithAggregatesInput[]
+    OR?: LoggedScalarWhereWithAggregatesInput[]
+    NOT?: LoggedScalarWhereWithAggregatesInput | LoggedScalarWhereWithAggregatesInput[]
+    id?: StringWithAggregatesFilter<"Logged"> | string
+    chainId?: IntWithAggregatesFilter<"Logged"> | number
+    type?: EnumLoggedEntityTypeWithAggregatesFilter<"Logged"> | $Enums.LoggedEntityType
+    address?: StringNullableWithAggregatesFilter<"Logged"> | string | null
+    fetchAtBlock?: IntWithAggregatesFilter<"Logged"> | number
+    caughtFromAddress?: StringWithAggregatesFilter<"Logged"> | string
+    entityData?: JsonWithAggregatesFilter<"Logged">
+  }
+
   export type CampaignCreateInput = {
     id: string
     campaignId: string
@@ -34160,6 +35431,76 @@ export namespace Prisma {
     timestamp?: IntFieldUpdateOperationsInput | number
   }
 
+  export type LoggedCreateInput = {
+    id: string
+    chainId: number
+    type?: $Enums.LoggedEntityType
+    address?: string | null
+    fetchAtBlock: number
+    caughtFromAddress: string
+    entityData: JsonNullValueInput | InputJsonValue
+  }
+
+  export type LoggedUncheckedCreateInput = {
+    id: string
+    chainId: number
+    type?: $Enums.LoggedEntityType
+    address?: string | null
+    fetchAtBlock: number
+    caughtFromAddress: string
+    entityData: JsonNullValueInput | InputJsonValue
+  }
+
+  export type LoggedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    chainId?: IntFieldUpdateOperationsInput | number
+    type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
+    address?: NullableStringFieldUpdateOperationsInput | string | null
+    fetchAtBlock?: IntFieldUpdateOperationsInput | number
+    caughtFromAddress?: StringFieldUpdateOperationsInput | string
+    entityData?: JsonNullValueInput | InputJsonValue
+  }
+
+  export type LoggedUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    chainId?: IntFieldUpdateOperationsInput | number
+    type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
+    address?: NullableStringFieldUpdateOperationsInput | string | null
+    fetchAtBlock?: IntFieldUpdateOperationsInput | number
+    caughtFromAddress?: StringFieldUpdateOperationsInput | string
+    entityData?: JsonNullValueInput | InputJsonValue
+  }
+
+  export type LoggedCreateManyInput = {
+    id: string
+    chainId: number
+    type?: $Enums.LoggedEntityType
+    address?: string | null
+    fetchAtBlock: number
+    caughtFromAddress: string
+    entityData: JsonNullValueInput | InputJsonValue
+  }
+
+  export type LoggedUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    chainId?: IntFieldUpdateOperationsInput | number
+    type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
+    address?: NullableStringFieldUpdateOperationsInput | string | null
+    fetchAtBlock?: IntFieldUpdateOperationsInput | number
+    caughtFromAddress?: StringFieldUpdateOperationsInput | string
+    entityData?: JsonNullValueInput | InputJsonValue
+  }
+
+  export type LoggedUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    chainId?: IntFieldUpdateOperationsInput | number
+    type?: EnumLoggedEntityTypeFieldUpdateOperationsInput | $Enums.LoggedEntityType
+    address?: NullableStringFieldUpdateOperationsInput | string | null
+    fetchAtBlock?: IntFieldUpdateOperationsInput | number
+    caughtFromAddress?: StringFieldUpdateOperationsInput | string
+    entityData?: JsonNullValueInput | InputJsonValue
+  }
+
   export type StringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -35916,6 +37257,72 @@ export namespace Prisma {
     _max?: NestedDateTimeFilter<$PrismaModel>
   }
 
+  export type EnumLoggedEntityTypeFilter<$PrismaModel = never> = {
+    equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    not?: NestedEnumLoggedEntityTypeFilter<$PrismaModel> | $Enums.LoggedEntityType
+  }
+
+  export type LoggedOrderByRelevanceInput = {
+    fields: LoggedOrderByRelevanceFieldEnum | LoggedOrderByRelevanceFieldEnum[]
+    sort: SortOrder
+    search: string
+  }
+
+  export type LoggedChainIdAddressCompoundUniqueInput = {
+    chainId: number
+    address: string
+  }
+
+  export type LoggedCountOrderByAggregateInput = {
+    id?: SortOrder
+    chainId?: SortOrder
+    type?: SortOrder
+    address?: SortOrder
+    fetchAtBlock?: SortOrder
+    caughtFromAddress?: SortOrder
+    entityData?: SortOrder
+  }
+
+  export type LoggedAvgOrderByAggregateInput = {
+    chainId?: SortOrder
+    fetchAtBlock?: SortOrder
+  }
+
+  export type LoggedMaxOrderByAggregateInput = {
+    id?: SortOrder
+    chainId?: SortOrder
+    type?: SortOrder
+    address?: SortOrder
+    fetchAtBlock?: SortOrder
+    caughtFromAddress?: SortOrder
+  }
+
+  export type LoggedMinOrderByAggregateInput = {
+    id?: SortOrder
+    chainId?: SortOrder
+    type?: SortOrder
+    address?: SortOrder
+    fetchAtBlock?: SortOrder
+    caughtFromAddress?: SortOrder
+  }
+
+  export type LoggedSumOrderByAggregateInput = {
+    chainId?: SortOrder
+    fetchAtBlock?: SortOrder
+  }
+
+  export type EnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    not?: NestedEnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel> | $Enums.LoggedEntityType
+    _count?: NestedIntFilter<$PrismaModel>
+    _min?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
+    _max?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
+  }
+
   export type ChainCreateNestedOneWithoutCampaignsInput = {
     create?: XOR<ChainCreateWithoutCampaignsInput, ChainUncheckedCreateWithoutCampaignsInput>
     connectOrCreate?: ChainCreateOrConnectWithoutCampaignsInput
@@ -38048,6 +39455,10 @@ export namespace Prisma {
     update?: XOR<XOR<TokenUpdateToOneWithWhereWithoutDumpToInput, TokenUpdateWithoutDumpToInput>, TokenUncheckedUpdateWithoutDumpToInput>
   }
 
+  export type EnumLoggedEntityTypeFieldUpdateOperationsInput = {
+    set?: $Enums.LoggedEntityType
+  }
+
   export type NestedStringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -38467,6 +39878,23 @@ export namespace Prisma {
     _max?: NestedDateTimeFilter<$PrismaModel>
   }
 
+  export type NestedEnumLoggedEntityTypeFilter<$PrismaModel = never> = {
+    equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    not?: NestedEnumLoggedEntityTypeFilter<$PrismaModel> | $Enums.LoggedEntityType
+  }
+
+  export type NestedEnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.LoggedEntityType | EnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    in?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    notIn?: $Enums.LoggedEntityType[] | ListEnumLoggedEntityTypeFieldRefInput<$PrismaModel>
+    not?: NestedEnumLoggedEntityTypeWithAggregatesFilter<$PrismaModel> | $Enums.LoggedEntityType
+    _count?: NestedIntFilter<$PrismaModel>
+    _min?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
+    _max?: NestedEnumLoggedEntityTypeFilter<$PrismaModel>
+  }
+
   export type ChainCreateWithoutCampaignsInput = {
     id: number
     name: string