@merkl/api 0.10.362 → 0.10.378

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

@@ -93,6 +93,11 @@ export type DailyRewardsBreakdown = $Result.DefaultSelection<Prisma.$DailyReward
  * 
  */
 export type User = $Result.DefaultSelection<Prisma.$UserPayload>
+/**
+ * Model Creator
+ * 
+ */
+export type Creator = $Result.DefaultSelection<Prisma.$CreatorPayload>
 /**
  * Model Reward
  * 
@@ -173,7 +178,6 @@ export const OpportunityAction: {
   DROP: 'DROP',
   LEND: 'LEND',
   BORROW: 'BORROW',
-  LP: 'LP',
   LONG: 'LONG',
   SHORT: 'SHORT',
   INVALID: 'INVALID'
@@ -546,6 +550,16 @@ export class PrismaClient<
     */
   get user(): Prisma.UserDelegate<ExtArgs>;
 
+  /**
+   * `prisma.creator`: Exposes CRUD operations for the **Creator** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Creators
+    * const creators = await prisma.creator.findMany()
+    * ```
+    */
+  get creator(): Prisma.CreatorDelegate<ExtArgs>;
+
   /**
    * `prisma.reward`: Exposes CRUD operations for the **Reward** model.
     * Example usage:
@@ -1061,6 +1075,7 @@ export namespace Prisma {
     DailyRewardsRecord: 'DailyRewardsRecord',
     DailyRewardsBreakdown: 'DailyRewardsBreakdown',
     User: 'User',
+    Creator: 'Creator',
     Reward: 'Reward',
     RewardBreakdown: 'RewardBreakdown',
     MerklRoot: 'MerklRoot',
@@ -1082,7 +1097,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" | "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"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -2206,6 +2221,76 @@ export namespace Prisma {
           }
         }
       }
+      Creator: {
+        payload: Prisma.$CreatorPayload<ExtArgs>
+        fields: Prisma.CreatorFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.CreatorFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.CreatorFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>
+          }
+          findFirst: {
+            args: Prisma.CreatorFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.CreatorFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>
+          }
+          findMany: {
+            args: Prisma.CreatorFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>[]
+          }
+          create: {
+            args: Prisma.CreatorCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>
+          }
+          createMany: {
+            args: Prisma.CreatorCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          createManyAndReturn: {
+            args: Prisma.CreatorCreateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>[]
+          }
+          delete: {
+            args: Prisma.CreatorDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>
+          }
+          update: {
+            args: Prisma.CreatorUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>
+          }
+          deleteMany: {
+            args: Prisma.CreatorDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.CreatorUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          upsert: {
+            args: Prisma.CreatorUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$CreatorPayload>
+          }
+          aggregate: {
+            args: Prisma.CreatorAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateCreator>
+          }
+          groupBy: {
+            args: Prisma.CreatorGroupByArgs<ExtArgs>
+            result: $Utils.Optional<CreatorGroupByOutputType>[]
+          }
+          count: {
+            args: Prisma.CreatorCountArgs<ExtArgs>
+            result: $Utils.Optional<CreatorCountAggregateOutputType> | number
+          }
+        }
+      }
       Reward: {
         payload: Prisma.$RewardPayload<ExtArgs>
         fields: Prisma.RewardFieldRefs
@@ -3286,6 +3371,37 @@ export namespace Prisma {
   }
 
 
+  /**
+   * Count Type CreatorCountOutputType
+   */
+
+  export type CreatorCountOutputType = {
+    Users: number
+  }
+
+  export type CreatorCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    Users?: boolean | CreatorCountOutputTypeCountUsersArgs
+  }
+
+  // Custom InputTypes
+  /**
+   * CreatorCountOutputType without action
+   */
+  export type CreatorCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the CreatorCountOutputType
+     */
+    select?: CreatorCountOutputTypeSelect<ExtArgs> | null
+  }
+
+  /**
+   * CreatorCountOutputType without action
+   */
+  export type CreatorCountOutputTypeCountUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: UserWhereInput
+  }
+
+
   /**
    * Count Type RewardCountOutputType
    */
@@ -6555,14 +6671,17 @@ export namespace Prisma {
   }
 
   export type UserComputedValueAvgAggregateOutputType = {
+    id: number | null
     boost: number | null
   }
 
   export type UserComputedValueSumAggregateOutputType = {
+    id: number | null
     boost: number | null
   }
 
   export type UserComputedValueMinAggregateOutputType = {
+    id: number | null
     campaignId: string | null
     address: string | null
     reason: string | null
@@ -6570,6 +6689,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueMaxAggregateOutputType = {
+    id: number | null
     campaignId: string | null
     address: string | null
     reason: string | null
@@ -6577,6 +6697,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueCountAggregateOutputType = {
+    id: number
     campaignId: number
     address: number
     reason: number
@@ -6586,14 +6707,17 @@ export namespace Prisma {
 
 
   export type UserComputedValueAvgAggregateInputType = {
+    id?: true
     boost?: true
   }
 
   export type UserComputedValueSumAggregateInputType = {
+    id?: true
     boost?: true
   }
 
   export type UserComputedValueMinAggregateInputType = {
+    id?: true
     campaignId?: true
     address?: true
     reason?: true
@@ -6601,6 +6725,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueMaxAggregateInputType = {
+    id?: true
     campaignId?: true
     address?: true
     reason?: true
@@ -6608,6 +6733,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueCountAggregateInputType = {
+    id?: true
     campaignId?: true
     address?: true
     reason?: true
@@ -6702,6 +6828,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueGroupByOutputType = {
+    id: number
     campaignId: string
     address: string
     reason: string
@@ -6728,6 +6855,7 @@ export namespace Prisma {
 
 
   export type UserComputedValueSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
     campaignId?: boolean
     address?: boolean
     reason?: boolean
@@ -6737,6 +6865,7 @@ export namespace Prisma {
   }, ExtArgs["result"]["userComputedValue"]>
 
   export type UserComputedValueSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
     campaignId?: boolean
     address?: boolean
     reason?: boolean
@@ -6746,6 +6875,7 @@ export namespace Prisma {
   }, ExtArgs["result"]["userComputedValue"]>
 
   export type UserComputedValueSelectScalar = {
+    id?: boolean
     campaignId?: boolean
     address?: boolean
     reason?: boolean
@@ -6768,6 +6898,7 @@ export namespace Prisma {
       User: Prisma.$UserPayload<ExtArgs> | null
     }
     scalars: $Extensions.GetPayloadResult<{
+      id: number
       campaignId: string
       address: string
       reason: string
@@ -6855,8 +6986,8 @@ export namespace Prisma {
      * // Get first 10 UserComputedValues
      * const userComputedValues = await prisma.userComputedValue.findMany({ take: 10 })
      * 
-     * // Only select the `campaignId`
-     * const userComputedValueWithCampaignIdOnly = await prisma.userComputedValue.findMany({ select: { campaignId: true } })
+     * // Only select the `id`
+     * const userComputedValueWithIdOnly = await prisma.userComputedValue.findMany({ select: { id: true } })
      * 
      */
     findMany<T extends UserComputedValueFindManyArgs>(args?: SelectSubset<T, UserComputedValueFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserComputedValuePayload<ExtArgs>, T, "findMany">>
@@ -6900,9 +7031,9 @@ export namespace Prisma {
      *   ]
      * })
      * 
-     * // Create many UserComputedValues and only return the `campaignId`
-     * const userComputedValueWithCampaignIdOnly = await prisma.userComputedValue.createManyAndReturn({ 
-     *   select: { campaignId: true },
+     * // Create many UserComputedValues and only return the `id`
+     * const userComputedValueWithIdOnly = await prisma.userComputedValue.createManyAndReturn({ 
+     *   select: { id: true },
      *   data: [
      *     // ... provide data here
      *   ]
@@ -7167,6 +7298,7 @@ export namespace Prisma {
    * Fields of the UserComputedValue model
    */ 
   interface UserComputedValueFieldRefs {
+    readonly id: FieldRef<"UserComputedValue", 'Int'>
     readonly campaignId: FieldRef<"UserComputedValue", 'String'>
     readonly address: FieldRef<"UserComputedValue", 'String'>
     readonly reason: FieldRef<"UserComputedValue", 'String'>
@@ -18992,30 +19124,36 @@ export namespace Prisma {
 
   export type UserMinAggregateOutputType = {
     address: string | null
+    creatorId: string | null
   }
 
   export type UserMaxAggregateOutputType = {
     address: string | null
+    creatorId: string | null
   }
 
   export type UserCountAggregateOutputType = {
     address: number
     tags: number
+    creatorId: number
     _all: number
   }
 
 
   export type UserMinAggregateInputType = {
     address?: true
+    creatorId?: true
   }
 
   export type UserMaxAggregateInputType = {
     address?: true
+    creatorId?: true
   }
 
   export type UserCountAggregateInputType = {
     address?: true
     tags?: true
+    creatorId?: true
     _all?: true
   }
 
@@ -19094,6 +19232,7 @@ export namespace Prisma {
   export type UserGroupByOutputType = {
     address: string
     tags: string[]
+    creatorId: string | null
     _count: UserCountAggregateOutputType | null
     _min: UserMinAggregateOutputType | null
     _max: UserMaxAggregateOutputType | null
@@ -19116,21 +19255,26 @@ export namespace Prisma {
   export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     address?: boolean
     tags?: boolean
+    creatorId?: boolean
     Rewards?: boolean | User$RewardsArgs<ExtArgs>
     Blacklist?: boolean | User$BlacklistArgs<ExtArgs>
     CampaignsCreated?: boolean | User$CampaignsCreatedArgs<ExtArgs>
     UserComputedValue?: boolean | User$UserComputedValueArgs<ExtArgs>
+    Creator?: boolean | User$CreatorArgs<ExtArgs>
     _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["user"]>
 
   export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     address?: boolean
     tags?: boolean
+    creatorId?: boolean
+    Creator?: boolean | User$CreatorArgs<ExtArgs>
   }, ExtArgs["result"]["user"]>
 
   export type UserSelectScalar = {
     address?: boolean
     tags?: boolean
+    creatorId?: boolean
   }
 
   export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
@@ -19138,9 +19282,12 @@ export namespace Prisma {
     Blacklist?: boolean | User$BlacklistArgs<ExtArgs>
     CampaignsCreated?: boolean | User$CampaignsCreatedArgs<ExtArgs>
     UserComputedValue?: boolean | User$UserComputedValueArgs<ExtArgs>
+    Creator?: boolean | User$CreatorArgs<ExtArgs>
     _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
   }
-  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
+  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    Creator?: boolean | User$CreatorArgs<ExtArgs>
+  }
 
   export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     name: "User"
@@ -19149,10 +19296,12 @@ export namespace Prisma {
       Blacklist: Prisma.$BlacklistPayload<ExtArgs>[]
       CampaignsCreated: Prisma.$CampaignPayload<ExtArgs>[]
       UserComputedValue: Prisma.$UserComputedValuePayload<ExtArgs>[]
+      Creator: Prisma.$CreatorPayload<ExtArgs> | null
     }
     scalars: $Extensions.GetPayloadResult<{
       address: string
       tags: string[]
+      creatorId: string | null
     }, ExtArgs["result"]["user"]>
     composites: {}
   }
@@ -19521,6 +19670,7 @@ export namespace Prisma {
     Blacklist<T extends User$BlacklistArgs<ExtArgs> = {}>(args?: Subset<T, User$BlacklistArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BlacklistPayload<ExtArgs>, T, "findMany"> | Null>
     CampaignsCreated<T extends User$CampaignsCreatedArgs<ExtArgs> = {}>(args?: Subset<T, User$CampaignsCreatedArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CampaignPayload<ExtArgs>, T, "findMany"> | Null>
     UserComputedValue<T extends User$UserComputedValueArgs<ExtArgs> = {}>(args?: Subset<T, User$UserComputedValueArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserComputedValuePayload<ExtArgs>, T, "findMany"> | Null>
+    Creator<T extends User$CreatorArgs<ExtArgs> = {}>(args?: Subset<T, User$CreatorArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
      * @param onfulfilled The callback to execute when the Promise is resolved.
@@ -19552,6 +19702,7 @@ export namespace Prisma {
   interface UserFieldRefs {
     readonly address: FieldRef<"User", 'String'>
     readonly tags: FieldRef<"User", 'String[]'>
+    readonly creatorId: FieldRef<"User", 'String'>
   }
     
 
@@ -19779,6 +19930,10 @@ export namespace Prisma {
      */
     data: UserCreateManyInput | UserCreateManyInput[]
     skipDuplicates?: boolean
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: UserIncludeCreateManyAndReturn<ExtArgs> | null
   }
 
   /**
@@ -19954,6 +20109,21 @@ export namespace Prisma {
     distinct?: UserComputedValueScalarFieldEnum | UserComputedValueScalarFieldEnum[]
   }
 
+  /**
+   * User.Creator
+   */
+  export type User$CreatorArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    where?: CreatorWhereInput
+  }
+
   /**
    * User without action
    */
@@ -19970,381 +20140,314 @@ export namespace Prisma {
 
 
   /**
-   * Model Reward
+   * Model Creator
    */
 
-  export type AggregateReward = {
-    _count: RewardCountAggregateOutputType | null
-    _min: RewardMinAggregateOutputType | null
-    _max: RewardMaxAggregateOutputType | null
+  export type AggregateCreator = {
+    _count: CreatorCountAggregateOutputType | null
+    _min: CreatorMinAggregateOutputType | null
+    _max: CreatorMaxAggregateOutputType | null
   }
 
-  export type RewardMinAggregateOutputType = {
+  export type CreatorMinAggregateOutputType = {
     id: string | null
-    root: string | null
-    recipient: string | null
-    rewardTokenId: string | null
-    amount: string | null
-    claimed: string | null
-    pending: string | null
+    icon: string | null
+    name: string | null
   }
 
-  export type RewardMaxAggregateOutputType = {
+  export type CreatorMaxAggregateOutputType = {
     id: string | null
-    root: string | null
-    recipient: string | null
-    rewardTokenId: string | null
-    amount: string | null
-    claimed: string | null
-    pending: string | null
+    icon: string | null
+    name: string | null
   }
 
-  export type RewardCountAggregateOutputType = {
+  export type CreatorCountAggregateOutputType = {
     id: number
-    root: number
-    recipient: number
-    rewardTokenId: number
-    amount: number
-    claimed: number
-    pending: number
-    proofs: number
+    icon: number
+    name: number
     _all: number
   }
 
 
-  export type RewardMinAggregateInputType = {
+  export type CreatorMinAggregateInputType = {
     id?: true
-    root?: true
-    recipient?: true
-    rewardTokenId?: true
-    amount?: true
-    claimed?: true
-    pending?: true
+    icon?: true
+    name?: true
   }
 
-  export type RewardMaxAggregateInputType = {
+  export type CreatorMaxAggregateInputType = {
     id?: true
-    root?: true
-    recipient?: true
-    rewardTokenId?: true
-    amount?: true
-    claimed?: true
-    pending?: true
+    icon?: true
+    name?: true
   }
 
-  export type RewardCountAggregateInputType = {
+  export type CreatorCountAggregateInputType = {
     id?: true
-    root?: true
-    recipient?: true
-    rewardTokenId?: true
-    amount?: true
-    claimed?: true
-    pending?: true
-    proofs?: true
+    icon?: true
+    name?: true
     _all?: true
   }
 
-  export type RewardAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type CreatorAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Filter which Reward to aggregate.
+     * Filter which Creator to aggregate.
      */
-    where?: RewardWhereInput
+    where?: CreatorWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of Rewards to fetch.
+     * Determine the order of Creators to fetch.
      */
-    orderBy?: RewardOrderByWithRelationInput | RewardOrderByWithRelationInput[]
+    orderBy?: CreatorOrderByWithRelationInput | CreatorOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
      * Sets the start position
      */
-    cursor?: RewardWhereUniqueInput
+    cursor?: CreatorWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` Rewards from the position of the cursor.
+     * Take `±n` Creators 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` Rewards.
+     * Skip the first `n` Creators.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
-     * Count returned Rewards
+     * Count returned Creators
     **/
-    _count?: true | RewardCountAggregateInputType
+    _count?: true | CreatorCountAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the minimum value
     **/
-    _min?: RewardMinAggregateInputType
+    _min?: CreatorMinAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the maximum value
     **/
-    _max?: RewardMaxAggregateInputType
+    _max?: CreatorMaxAggregateInputType
   }
 
-  export type GetRewardAggregateType<T extends RewardAggregateArgs> = {
-        [P in keyof T & keyof AggregateReward]: P extends '_count' | 'count'
+  export type GetCreatorAggregateType<T extends CreatorAggregateArgs> = {
+        [P in keyof T & keyof AggregateCreator]: P extends '_count' | 'count'
       ? T[P] extends true
         ? number
-        : GetScalarType<T[P], AggregateReward[P]>
-      : GetScalarType<T[P], AggregateReward[P]>
+        : GetScalarType<T[P], AggregateCreator[P]>
+      : GetScalarType<T[P], AggregateCreator[P]>
   }
 
 
 
 
-  export type RewardGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: RewardWhereInput
-    orderBy?: RewardOrderByWithAggregationInput | RewardOrderByWithAggregationInput[]
-    by: RewardScalarFieldEnum[] | RewardScalarFieldEnum
-    having?: RewardScalarWhereWithAggregatesInput
+  export type CreatorGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: CreatorWhereInput
+    orderBy?: CreatorOrderByWithAggregationInput | CreatorOrderByWithAggregationInput[]
+    by: CreatorScalarFieldEnum[] | CreatorScalarFieldEnum
+    having?: CreatorScalarWhereWithAggregatesInput
     take?: number
     skip?: number
-    _count?: RewardCountAggregateInputType | true
-    _min?: RewardMinAggregateInputType
-    _max?: RewardMaxAggregateInputType
+    _count?: CreatorCountAggregateInputType | true
+    _min?: CreatorMinAggregateInputType
+    _max?: CreatorMaxAggregateInputType
   }
 
-  export type RewardGroupByOutputType = {
+  export type CreatorGroupByOutputType = {
     id: string
-    root: string
-    recipient: string
-    rewardTokenId: string
-    amount: string
-    claimed: string
-    pending: string
-    proofs: string[]
-    _count: RewardCountAggregateOutputType | null
-    _min: RewardMinAggregateOutputType | null
-    _max: RewardMaxAggregateOutputType | null
+    icon: string | null
+    name: string
+    _count: CreatorCountAggregateOutputType | null
+    _min: CreatorMinAggregateOutputType | null
+    _max: CreatorMaxAggregateOutputType | null
   }
 
-  type GetRewardGroupByPayload<T extends RewardGroupByArgs> = Prisma.PrismaPromise<
+  type GetCreatorGroupByPayload<T extends CreatorGroupByArgs> = Prisma.PrismaPromise<
     Array<
-      PickEnumerable<RewardGroupByOutputType, T['by']> &
+      PickEnumerable<CreatorGroupByOutputType, T['by']> &
         {
-          [P in ((keyof T) & (keyof RewardGroupByOutputType))]: P extends '_count'
+          [P in ((keyof T) & (keyof CreatorGroupByOutputType))]: P extends '_count'
             ? T[P] extends boolean
               ? number
-              : GetScalarType<T[P], RewardGroupByOutputType[P]>
-            : GetScalarType<T[P], RewardGroupByOutputType[P]>
+              : GetScalarType<T[P], CreatorGroupByOutputType[P]>
+            : GetScalarType<T[P], CreatorGroupByOutputType[P]>
         }
       >
     >
 
 
-  export type RewardSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+  export type CreatorSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
-    root?: boolean
-    recipient?: boolean
-    rewardTokenId?: boolean
-    amount?: boolean
-    claimed?: boolean
-    pending?: boolean
-    proofs?: boolean
-    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
-    User?: boolean | UserDefaultArgs<ExtArgs>
-    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
-    Breakdown?: boolean | Reward$BreakdownArgs<ExtArgs>
-    _count?: boolean | RewardCountOutputTypeDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["reward"]>
+    icon?: boolean
+    name?: boolean
+    Users?: boolean | Creator$UsersArgs<ExtArgs>
+    _count?: boolean | CreatorCountOutputTypeDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["creator"]>
 
-  export type RewardSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+  export type CreatorSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
-    root?: boolean
-    recipient?: boolean
-    rewardTokenId?: boolean
-    amount?: boolean
-    claimed?: boolean
-    pending?: boolean
-    proofs?: boolean
-    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
-    User?: boolean | UserDefaultArgs<ExtArgs>
-    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["reward"]>
+    icon?: boolean
+    name?: boolean
+  }, ExtArgs["result"]["creator"]>
 
-  export type RewardSelectScalar = {
+  export type CreatorSelectScalar = {
     id?: boolean
-    root?: boolean
-    recipient?: boolean
-    rewardTokenId?: boolean
-    amount?: boolean
-    claimed?: boolean
-    pending?: boolean
-    proofs?: boolean
+    icon?: boolean
+    name?: boolean
   }
 
-  export type RewardInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
-    User?: boolean | UserDefaultArgs<ExtArgs>
-    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
-    Breakdown?: boolean | Reward$BreakdownArgs<ExtArgs>
-    _count?: boolean | RewardCountOutputTypeDefaultArgs<ExtArgs>
-  }
-  export type RewardIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
-    User?: boolean | UserDefaultArgs<ExtArgs>
-    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
+  export type CreatorInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    Users?: boolean | Creator$UsersArgs<ExtArgs>
+    _count?: boolean | CreatorCountOutputTypeDefaultArgs<ExtArgs>
   }
+  export type CreatorIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
 
-  export type $RewardPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    name: "Reward"
+  export type $CreatorPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "Creator"
     objects: {
-      MerklRoot: Prisma.$MerklRootPayload<ExtArgs>
-      User: Prisma.$UserPayload<ExtArgs>
-      RewardToken: Prisma.$TokenPayload<ExtArgs>
-      Breakdown: Prisma.$RewardBreakdownPayload<ExtArgs>[]
+      Users: Prisma.$UserPayload<ExtArgs>[]
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
-      root: string
-      recipient: string
-      rewardTokenId: string
-      amount: string
-      claimed: string
-      pending: string
-      proofs: string[]
-    }, ExtArgs["result"]["reward"]>
+      icon: string | null
+      name: string
+    }, ExtArgs["result"]["creator"]>
     composites: {}
   }
 
-  type RewardGetPayload<S extends boolean | null | undefined | RewardDefaultArgs> = $Result.GetResult<Prisma.$RewardPayload, S>
+  type CreatorGetPayload<S extends boolean | null | undefined | CreatorDefaultArgs> = $Result.GetResult<Prisma.$CreatorPayload, S>
 
-  type RewardCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
-    Omit<RewardFindManyArgs, 'select' | 'include' | 'distinct' | 'relationLoadStrategy'> & {
-      select?: RewardCountAggregateInputType | true
+  type CreatorCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
+    Omit<CreatorFindManyArgs, 'select' | 'include' | 'distinct' | 'relationLoadStrategy'> & {
+      select?: CreatorCountAggregateInputType | true
     }
 
-  export interface RewardDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
-    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Reward'], meta: { name: 'Reward' } }
+  export interface CreatorDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Creator'], meta: { name: 'Creator' } }
     /**
-     * Find zero or one Reward that matches the filter.
-     * @param {RewardFindUniqueArgs} args - Arguments to find a Reward
+     * Find zero or one Creator that matches the filter.
+     * @param {CreatorFindUniqueArgs} args - Arguments to find a Creator
      * @example
-     * // Get one Reward
-     * const reward = await prisma.reward.findUnique({
+     * // Get one Creator
+     * const creator = await prisma.creator.findUnique({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findUnique<T extends RewardFindUniqueArgs>(args: SelectSubset<T, RewardFindUniqueArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
+    findUnique<T extends CreatorFindUniqueArgs>(args: SelectSubset<T, CreatorFindUniqueArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
 
     /**
-     * Find one Reward that matches the filter or throw an error with `error.code='P2025'` 
+     * Find one Creator that matches the filter or throw an error with `error.code='P2025'` 
      * if no matches were found.
-     * @param {RewardFindUniqueOrThrowArgs} args - Arguments to find a Reward
+     * @param {CreatorFindUniqueOrThrowArgs} args - Arguments to find a Creator
      * @example
-     * // Get one Reward
-     * const reward = await prisma.reward.findUniqueOrThrow({
+     * // Get one Creator
+     * const creator = await prisma.creator.findUniqueOrThrow({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findUniqueOrThrow<T extends RewardFindUniqueOrThrowArgs>(args: SelectSubset<T, RewardFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
+    findUniqueOrThrow<T extends CreatorFindUniqueOrThrowArgs>(args: SelectSubset<T, CreatorFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
 
     /**
-     * Find the first Reward that matches the filter.
+     * Find the first Creator 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 {RewardFindFirstArgs} args - Arguments to find a Reward
+     * @param {CreatorFindFirstArgs} args - Arguments to find a Creator
      * @example
-     * // Get one Reward
-     * const reward = await prisma.reward.findFirst({
+     * // Get one Creator
+     * const creator = await prisma.creator.findFirst({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findFirst<T extends RewardFindFirstArgs>(args?: SelectSubset<T, RewardFindFirstArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
+    findFirst<T extends CreatorFindFirstArgs>(args?: SelectSubset<T, CreatorFindFirstArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
 
     /**
-     * Find the first Reward that matches the filter or
+     * Find the first Creator 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 {RewardFindFirstOrThrowArgs} args - Arguments to find a Reward
+     * @param {CreatorFindFirstOrThrowArgs} args - Arguments to find a Creator
      * @example
-     * // Get one Reward
-     * const reward = await prisma.reward.findFirstOrThrow({
+     * // Get one Creator
+     * const creator = await prisma.creator.findFirstOrThrow({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findFirstOrThrow<T extends RewardFindFirstOrThrowArgs>(args?: SelectSubset<T, RewardFindFirstOrThrowArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
+    findFirstOrThrow<T extends CreatorFindFirstOrThrowArgs>(args?: SelectSubset<T, CreatorFindFirstOrThrowArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
 
     /**
-     * Find zero or more Rewards that matches the filter.
+     * Find zero or more Creators 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 {RewardFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @param {CreatorFindManyArgs} args - Arguments to filter and select certain fields only.
      * @example
-     * // Get all Rewards
-     * const rewards = await prisma.reward.findMany()
+     * // Get all Creators
+     * const creators = await prisma.creator.findMany()
      * 
-     * // Get first 10 Rewards
-     * const rewards = await prisma.reward.findMany({ take: 10 })
+     * // Get first 10 Creators
+     * const creators = await prisma.creator.findMany({ take: 10 })
      * 
      * // Only select the `id`
-     * const rewardWithIdOnly = await prisma.reward.findMany({ select: { id: true } })
+     * const creatorWithIdOnly = await prisma.creator.findMany({ select: { id: true } })
      * 
      */
-    findMany<T extends RewardFindManyArgs>(args?: SelectSubset<T, RewardFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findMany">>
+    findMany<T extends CreatorFindManyArgs>(args?: SelectSubset<T, CreatorFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "findMany">>
 
     /**
-     * Create a Reward.
-     * @param {RewardCreateArgs} args - Arguments to create a Reward.
+     * Create a Creator.
+     * @param {CreatorCreateArgs} args - Arguments to create a Creator.
      * @example
-     * // Create one Reward
-     * const Reward = await prisma.reward.create({
+     * // Create one Creator
+     * const Creator = await prisma.creator.create({
      *   data: {
-     *     // ... data to create a Reward
+     *     // ... data to create a Creator
      *   }
      * })
      * 
      */
-    create<T extends RewardCreateArgs>(args: SelectSubset<T, RewardCreateArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "create">, never, ExtArgs>
+    create<T extends CreatorCreateArgs>(args: SelectSubset<T, CreatorCreateArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "create">, never, ExtArgs>
 
     /**
-     * Create many Rewards.
-     * @param {RewardCreateManyArgs} args - Arguments to create many Rewards.
+     * Create many Creators.
+     * @param {CreatorCreateManyArgs} args - Arguments to create many Creators.
      * @example
-     * // Create many Rewards
-     * const reward = await prisma.reward.createMany({
+     * // Create many Creators
+     * const creator = await prisma.creator.createMany({
      *   data: [
      *     // ... provide data here
      *   ]
      * })
      *     
      */
-    createMany<T extends RewardCreateManyArgs>(args?: SelectSubset<T, RewardCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+    createMany<T extends CreatorCreateManyArgs>(args?: SelectSubset<T, CreatorCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
 
     /**
-     * Create many Rewards and returns the data saved in the database.
-     * @param {RewardCreateManyAndReturnArgs} args - Arguments to create many Rewards.
+     * Create many Creators and returns the data saved in the database.
+     * @param {CreatorCreateManyAndReturnArgs} args - Arguments to create many Creators.
      * @example
-     * // Create many Rewards
-     * const reward = await prisma.reward.createManyAndReturn({
+     * // Create many Creators
+     * const creator = await prisma.creator.createManyAndReturn({
      *   data: [
      *     // ... provide data here
      *   ]
      * })
      * 
-     * // Create many Rewards and only return the `id`
-     * const rewardWithIdOnly = await prisma.reward.createManyAndReturn({ 
+     * // Create many Creators and only return the `id`
+     * const creatorWithIdOnly = await prisma.creator.createManyAndReturn({ 
      *   select: { id: true },
      *   data: [
      *     // ... provide data here
@@ -20354,28 +20457,28 @@ export namespace Prisma {
      * Read more here: https://pris.ly/d/null-undefined
      * 
      */
-    createManyAndReturn<T extends RewardCreateManyAndReturnArgs>(args?: SelectSubset<T, RewardCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "createManyAndReturn">>
+    createManyAndReturn<T extends CreatorCreateManyAndReturnArgs>(args?: SelectSubset<T, CreatorCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "createManyAndReturn">>
 
     /**
-     * Delete a Reward.
-     * @param {RewardDeleteArgs} args - Arguments to delete one Reward.
+     * Delete a Creator.
+     * @param {CreatorDeleteArgs} args - Arguments to delete one Creator.
      * @example
-     * // Delete one Reward
-     * const Reward = await prisma.reward.delete({
+     * // Delete one Creator
+     * const Creator = await prisma.creator.delete({
      *   where: {
-     *     // ... filter to delete one Reward
+     *     // ... filter to delete one Creator
      *   }
      * })
      * 
      */
-    delete<T extends RewardDeleteArgs>(args: SelectSubset<T, RewardDeleteArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "delete">, never, ExtArgs>
+    delete<T extends CreatorDeleteArgs>(args: SelectSubset<T, CreatorDeleteArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "delete">, never, ExtArgs>
 
     /**
-     * Update one Reward.
-     * @param {RewardUpdateArgs} args - Arguments to update one Reward.
+     * Update one Creator.
+     * @param {CreatorUpdateArgs} args - Arguments to update one Creator.
      * @example
-     * // Update one Reward
-     * const reward = await prisma.reward.update({
+     * // Update one Creator
+     * const creator = await prisma.creator.update({
      *   where: {
      *     // ... provide filter here
      *   },
@@ -20385,30 +20488,30 @@ export namespace Prisma {
      * })
      * 
      */
-    update<T extends RewardUpdateArgs>(args: SelectSubset<T, RewardUpdateArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "update">, never, ExtArgs>
+    update<T extends CreatorUpdateArgs>(args: SelectSubset<T, CreatorUpdateArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "update">, never, ExtArgs>
 
     /**
-     * Delete zero or more Rewards.
-     * @param {RewardDeleteManyArgs} args - Arguments to filter Rewards to delete.
+     * Delete zero or more Creators.
+     * @param {CreatorDeleteManyArgs} args - Arguments to filter Creators to delete.
      * @example
-     * // Delete a few Rewards
-     * const { count } = await prisma.reward.deleteMany({
+     * // Delete a few Creators
+     * const { count } = await prisma.creator.deleteMany({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      * 
      */
-    deleteMany<T extends RewardDeleteManyArgs>(args?: SelectSubset<T, RewardDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+    deleteMany<T extends CreatorDeleteManyArgs>(args?: SelectSubset<T, CreatorDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
 
     /**
-     * Update zero or more Rewards.
+     * Update zero or more Creators.
      * Note, that providing `undefined` is treated as the value not being there.
      * Read more here: https://pris.ly/d/null-undefined
-     * @param {RewardUpdateManyArgs} args - Arguments to update one or more rows.
+     * @param {CreatorUpdateManyArgs} args - Arguments to update one or more rows.
      * @example
-     * // Update many Rewards
-     * const reward = await prisma.reward.updateMany({
+     * // Update many Creators
+     * const creator = await prisma.creator.updateMany({
      *   where: {
      *     // ... provide filter here
      *   },
@@ -20418,56 +20521,56 @@ export namespace Prisma {
      * })
      * 
      */
-    updateMany<T extends RewardUpdateManyArgs>(args: SelectSubset<T, RewardUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+    updateMany<T extends CreatorUpdateManyArgs>(args: SelectSubset<T, CreatorUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
 
     /**
-     * Create or update one Reward.
-     * @param {RewardUpsertArgs} args - Arguments to update or create a Reward.
+     * Create or update one Creator.
+     * @param {CreatorUpsertArgs} args - Arguments to update or create a Creator.
      * @example
-     * // Update or create a Reward
-     * const reward = await prisma.reward.upsert({
+     * // Update or create a Creator
+     * const creator = await prisma.creator.upsert({
      *   create: {
-     *     // ... data to create a Reward
+     *     // ... data to create a Creator
      *   },
      *   update: {
      *     // ... in case it already exists, update
      *   },
      *   where: {
-     *     // ... the filter for the Reward we want to update
+     *     // ... the filter for the Creator we want to update
      *   }
      * })
      */
-    upsert<T extends RewardUpsertArgs>(args: SelectSubset<T, RewardUpsertArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
+    upsert<T extends CreatorUpsertArgs>(args: SelectSubset<T, CreatorUpsertArgs<ExtArgs>>): Prisma__CreatorClient<$Result.GetResult<Prisma.$CreatorPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
 
 
     /**
-     * Count the number of Rewards.
+     * Count the number of Creators.
      * Note, that providing `undefined` is treated as the value not being there.
      * Read more here: https://pris.ly/d/null-undefined
-     * @param {RewardCountArgs} args - Arguments to filter Rewards to count.
+     * @param {CreatorCountArgs} args - Arguments to filter Creators to count.
      * @example
-     * // Count the number of Rewards
-     * const count = await prisma.reward.count({
+     * // Count the number of Creators
+     * const count = await prisma.creator.count({
      *   where: {
-     *     // ... the filter for the Rewards we want to count
+     *     // ... the filter for the Creators we want to count
      *   }
      * })
     **/
-    count<T extends RewardCountArgs>(
-      args?: Subset<T, RewardCountArgs>,
+    count<T extends CreatorCountArgs>(
+      args?: Subset<T, CreatorCountArgs>,
     ): Prisma.PrismaPromise<
       T extends $Utils.Record<'select', any>
         ? T['select'] extends true
           ? number
-          : GetScalarType<T['select'], RewardCountAggregateOutputType>
+          : GetScalarType<T['select'], CreatorCountAggregateOutputType>
         : number
     >
 
     /**
-     * Allows you to perform aggregations operations on a Reward.
+     * Allows you to perform aggregations operations on a Creator.
      * Note, that providing `undefined` is treated as the value not being there.
      * Read more here: https://pris.ly/d/null-undefined
-     * @param {RewardAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+     * @param {CreatorAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
      * @example
      * // Ordered by age ascending
      * // Where email contains prisma.io
@@ -20487,13 +20590,13 @@ export namespace Prisma {
      *   take: 10,
      * })
     **/
-    aggregate<T extends RewardAggregateArgs>(args: Subset<T, RewardAggregateArgs>): Prisma.PrismaPromise<GetRewardAggregateType<T>>
+    aggregate<T extends CreatorAggregateArgs>(args: Subset<T, CreatorAggregateArgs>): Prisma.PrismaPromise<GetCreatorAggregateType<T>>
 
     /**
-     * Group by Reward.
+     * Group by Creator.
      * Note, that providing `undefined` is treated as the value not being there.
      * Read more here: https://pris.ly/d/null-undefined
-     * @param {RewardGroupByArgs} args - Group by arguments.
+     * @param {CreatorGroupByArgs} args - Group by arguments.
      * @example
      * // Group by city, order by createdAt, get count
      * const result = await prisma.user.groupBy({
@@ -20508,14 +20611,1014 @@ export namespace Prisma {
      * 
     **/
     groupBy<
-      T extends RewardGroupByArgs,
+      T extends CreatorGroupByArgs,
       HasSelectOrTake extends Or<
         Extends<'skip', Keys<T>>,
         Extends<'take', Keys<T>>
       >,
       OrderByArg extends True extends HasSelectOrTake
-        ? { orderBy: RewardGroupByArgs['orderBy'] }
-        : { orderBy?: RewardGroupByArgs['orderBy'] },
+        ? { orderBy: CreatorGroupByArgs['orderBy'] }
+        : { orderBy?: CreatorGroupByArgs['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, CreatorGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCreatorGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the Creator model
+   */
+  readonly fields: CreatorFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for Creator.
+   * 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__CreatorClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    Users<T extends Creator$UsersArgs<ExtArgs> = {}>(args?: Subset<T, Creator$UsersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany"> | Null>
+    /**
+     * 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 Creator model
+   */ 
+  interface CreatorFieldRefs {
+    readonly id: FieldRef<"Creator", 'String'>
+    readonly icon: FieldRef<"Creator", 'String'>
+    readonly name: FieldRef<"Creator", 'String'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * Creator findUnique
+   */
+  export type CreatorFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * Filter, which Creator to fetch.
+     */
+    where: CreatorWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator findUniqueOrThrow
+   */
+  export type CreatorFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * Filter, which Creator to fetch.
+     */
+    where: CreatorWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator findFirst
+   */
+  export type CreatorFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * Filter, which Creator to fetch.
+     */
+    where?: CreatorWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Creators to fetch.
+     */
+    orderBy?: CreatorOrderByWithRelationInput | CreatorOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for Creators.
+     */
+    cursor?: CreatorWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Creators 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` Creators.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of Creators.
+     */
+    distinct?: CreatorScalarFieldEnum | CreatorScalarFieldEnum[]
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator findFirstOrThrow
+   */
+  export type CreatorFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * Filter, which Creator to fetch.
+     */
+    where?: CreatorWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Creators to fetch.
+     */
+    orderBy?: CreatorOrderByWithRelationInput | CreatorOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for Creators.
+     */
+    cursor?: CreatorWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Creators 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` Creators.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of Creators.
+     */
+    distinct?: CreatorScalarFieldEnum | CreatorScalarFieldEnum[]
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator findMany
+   */
+  export type CreatorFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * Filter, which Creators to fetch.
+     */
+    where?: CreatorWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Creators to fetch.
+     */
+    orderBy?: CreatorOrderByWithRelationInput | CreatorOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing Creators.
+     */
+    cursor?: CreatorWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Creators 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` Creators.
+     */
+    skip?: number
+    distinct?: CreatorScalarFieldEnum | CreatorScalarFieldEnum[]
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator create
+   */
+  export type CreatorCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * The data needed to create a Creator.
+     */
+    data: XOR<CreatorCreateInput, CreatorUncheckedCreateInput>
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator createMany
+   */
+  export type CreatorCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many Creators.
+     */
+    data: CreatorCreateManyInput | CreatorCreateManyInput[]
+    skipDuplicates?: boolean
+  }
+
+  /**
+   * Creator createManyAndReturn
+   */
+  export type CreatorCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelectCreateManyAndReturn<ExtArgs> | null
+    /**
+     * The data used to create many Creators.
+     */
+    data: CreatorCreateManyInput | CreatorCreateManyInput[]
+    skipDuplicates?: boolean
+  }
+
+  /**
+   * Creator update
+   */
+  export type CreatorUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * The data needed to update a Creator.
+     */
+    data: XOR<CreatorUpdateInput, CreatorUncheckedUpdateInput>
+    /**
+     * Choose, which Creator to update.
+     */
+    where: CreatorWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator updateMany
+   */
+  export type CreatorUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update Creators.
+     */
+    data: XOR<CreatorUpdateManyMutationInput, CreatorUncheckedUpdateManyInput>
+    /**
+     * Filter which Creators to update
+     */
+    where?: CreatorWhereInput
+  }
+
+  /**
+   * Creator upsert
+   */
+  export type CreatorUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * The filter to search for the Creator to update in case it exists.
+     */
+    where: CreatorWhereUniqueInput
+    /**
+     * In case the Creator found by the `where` argument doesn't exist, create a new Creator with this data.
+     */
+    create: XOR<CreatorCreateInput, CreatorUncheckedCreateInput>
+    /**
+     * In case the Creator was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<CreatorUpdateInput, CreatorUncheckedUpdateInput>
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator delete
+   */
+  export type CreatorDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+    /**
+     * Filter which Creator to delete.
+     */
+    where: CreatorWhereUniqueInput
+    relationLoadStrategy?: RelationLoadStrategy
+  }
+
+  /**
+   * Creator deleteMany
+   */
+  export type CreatorDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which Creators to delete
+     */
+    where?: CreatorWhereInput
+  }
+
+  /**
+   * Creator.Users
+   */
+  export type Creator$UsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: UserSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: UserInclude<ExtArgs> | null
+    where?: UserWhereInput
+    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
+    cursor?: UserWhereUniqueInput
+    take?: number
+    skip?: number
+    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
+  }
+
+  /**
+   * Creator without action
+   */
+  export type CreatorDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Creator
+     */
+    select?: CreatorSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: CreatorInclude<ExtArgs> | null
+  }
+
+
+  /**
+   * Model Reward
+   */
+
+  export type AggregateReward = {
+    _count: RewardCountAggregateOutputType | null
+    _min: RewardMinAggregateOutputType | null
+    _max: RewardMaxAggregateOutputType | null
+  }
+
+  export type RewardMinAggregateOutputType = {
+    id: string | null
+    root: string | null
+    recipient: string | null
+    rewardTokenId: string | null
+    amount: string | null
+    claimed: string | null
+    pending: string | null
+  }
+
+  export type RewardMaxAggregateOutputType = {
+    id: string | null
+    root: string | null
+    recipient: string | null
+    rewardTokenId: string | null
+    amount: string | null
+    claimed: string | null
+    pending: string | null
+  }
+
+  export type RewardCountAggregateOutputType = {
+    id: number
+    root: number
+    recipient: number
+    rewardTokenId: number
+    amount: number
+    claimed: number
+    pending: number
+    proofs: number
+    _all: number
+  }
+
+
+  export type RewardMinAggregateInputType = {
+    id?: true
+    root?: true
+    recipient?: true
+    rewardTokenId?: true
+    amount?: true
+    claimed?: true
+    pending?: true
+  }
+
+  export type RewardMaxAggregateInputType = {
+    id?: true
+    root?: true
+    recipient?: true
+    rewardTokenId?: true
+    amount?: true
+    claimed?: true
+    pending?: true
+  }
+
+  export type RewardCountAggregateInputType = {
+    id?: true
+    root?: true
+    recipient?: true
+    rewardTokenId?: true
+    amount?: true
+    claimed?: true
+    pending?: true
+    proofs?: true
+    _all?: true
+  }
+
+  export type RewardAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which Reward to aggregate.
+     */
+    where?: RewardWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Rewards to fetch.
+     */
+    orderBy?: RewardOrderByWithRelationInput | RewardOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: RewardWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Rewards 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` Rewards.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned Rewards
+    **/
+    _count?: true | RewardCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: RewardMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: RewardMaxAggregateInputType
+  }
+
+  export type GetRewardAggregateType<T extends RewardAggregateArgs> = {
+        [P in keyof T & keyof AggregateReward]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateReward[P]>
+      : GetScalarType<T[P], AggregateReward[P]>
+  }
+
+
+
+
+  export type RewardGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: RewardWhereInput
+    orderBy?: RewardOrderByWithAggregationInput | RewardOrderByWithAggregationInput[]
+    by: RewardScalarFieldEnum[] | RewardScalarFieldEnum
+    having?: RewardScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: RewardCountAggregateInputType | true
+    _min?: RewardMinAggregateInputType
+    _max?: RewardMaxAggregateInputType
+  }
+
+  export type RewardGroupByOutputType = {
+    id: string
+    root: string
+    recipient: string
+    rewardTokenId: string
+    amount: string
+    claimed: string
+    pending: string
+    proofs: string[]
+    _count: RewardCountAggregateOutputType | null
+    _min: RewardMinAggregateOutputType | null
+    _max: RewardMaxAggregateOutputType | null
+  }
+
+  type GetRewardGroupByPayload<T extends RewardGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<RewardGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof RewardGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], RewardGroupByOutputType[P]>
+            : GetScalarType<T[P], RewardGroupByOutputType[P]>
+        }
+      >
+    >
+
+
+  export type RewardSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    root?: boolean
+    recipient?: boolean
+    rewardTokenId?: boolean
+    amount?: boolean
+    claimed?: boolean
+    pending?: boolean
+    proofs?: boolean
+    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
+    User?: boolean | UserDefaultArgs<ExtArgs>
+    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
+    Breakdown?: boolean | Reward$BreakdownArgs<ExtArgs>
+    _count?: boolean | RewardCountOutputTypeDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["reward"]>
+
+  export type RewardSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    root?: boolean
+    recipient?: boolean
+    rewardTokenId?: boolean
+    amount?: boolean
+    claimed?: boolean
+    pending?: boolean
+    proofs?: boolean
+    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
+    User?: boolean | UserDefaultArgs<ExtArgs>
+    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["reward"]>
+
+  export type RewardSelectScalar = {
+    id?: boolean
+    root?: boolean
+    recipient?: boolean
+    rewardTokenId?: boolean
+    amount?: boolean
+    claimed?: boolean
+    pending?: boolean
+    proofs?: boolean
+  }
+
+  export type RewardInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
+    User?: boolean | UserDefaultArgs<ExtArgs>
+    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
+    Breakdown?: boolean | Reward$BreakdownArgs<ExtArgs>
+    _count?: boolean | RewardCountOutputTypeDefaultArgs<ExtArgs>
+  }
+  export type RewardIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    MerklRoot?: boolean | MerklRootDefaultArgs<ExtArgs>
+    User?: boolean | UserDefaultArgs<ExtArgs>
+    RewardToken?: boolean | TokenDefaultArgs<ExtArgs>
+  }
+
+  export type $RewardPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "Reward"
+    objects: {
+      MerklRoot: Prisma.$MerklRootPayload<ExtArgs>
+      User: Prisma.$UserPayload<ExtArgs>
+      RewardToken: Prisma.$TokenPayload<ExtArgs>
+      Breakdown: Prisma.$RewardBreakdownPayload<ExtArgs>[]
+    }
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      root: string
+      recipient: string
+      rewardTokenId: string
+      amount: string
+      claimed: string
+      pending: string
+      proofs: string[]
+    }, ExtArgs["result"]["reward"]>
+    composites: {}
+  }
+
+  type RewardGetPayload<S extends boolean | null | undefined | RewardDefaultArgs> = $Result.GetResult<Prisma.$RewardPayload, S>
+
+  type RewardCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
+    Omit<RewardFindManyArgs, 'select' | 'include' | 'distinct' | 'relationLoadStrategy'> & {
+      select?: RewardCountAggregateInputType | true
+    }
+
+  export interface RewardDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Reward'], meta: { name: 'Reward' } }
+    /**
+     * Find zero or one Reward that matches the filter.
+     * @param {RewardFindUniqueArgs} args - Arguments to find a Reward
+     * @example
+     * // Get one Reward
+     * const reward = await prisma.reward.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends RewardFindUniqueArgs>(args: SelectSubset<T, RewardFindUniqueArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
+
+    /**
+     * Find one Reward that matches the filter or throw an error with `error.code='P2025'` 
+     * if no matches were found.
+     * @param {RewardFindUniqueOrThrowArgs} args - Arguments to find a Reward
+     * @example
+     * // Get one Reward
+     * const reward = await prisma.reward.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends RewardFindUniqueOrThrowArgs>(args: SelectSubset<T, RewardFindUniqueOrThrowArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
+
+    /**
+     * Find the first Reward 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 {RewardFindFirstArgs} args - Arguments to find a Reward
+     * @example
+     * // Get one Reward
+     * const reward = await prisma.reward.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends RewardFindFirstArgs>(args?: SelectSubset<T, RewardFindFirstArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
+
+    /**
+     * Find the first Reward 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 {RewardFindFirstOrThrowArgs} args - Arguments to find a Reward
+     * @example
+     * // Get one Reward
+     * const reward = await prisma.reward.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends RewardFindFirstOrThrowArgs>(args?: SelectSubset<T, RewardFindFirstOrThrowArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
+
+    /**
+     * Find zero or more Rewards 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 {RewardFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Rewards
+     * const rewards = await prisma.reward.findMany()
+     * 
+     * // Get first 10 Rewards
+     * const rewards = await prisma.reward.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const rewardWithIdOnly = await prisma.reward.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends RewardFindManyArgs>(args?: SelectSubset<T, RewardFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "findMany">>
+
+    /**
+     * Create a Reward.
+     * @param {RewardCreateArgs} args - Arguments to create a Reward.
+     * @example
+     * // Create one Reward
+     * const Reward = await prisma.reward.create({
+     *   data: {
+     *     // ... data to create a Reward
+     *   }
+     * })
+     * 
+     */
+    create<T extends RewardCreateArgs>(args: SelectSubset<T, RewardCreateArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "create">, never, ExtArgs>
+
+    /**
+     * Create many Rewards.
+     * @param {RewardCreateManyArgs} args - Arguments to create many Rewards.
+     * @example
+     * // Create many Rewards
+     * const reward = await prisma.reward.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends RewardCreateManyArgs>(args?: SelectSubset<T, RewardCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many Rewards and returns the data saved in the database.
+     * @param {RewardCreateManyAndReturnArgs} args - Arguments to create many Rewards.
+     * @example
+     * // Create many Rewards
+     * const reward = await prisma.reward.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many Rewards and only return the `id`
+     * const rewardWithIdOnly = await prisma.reward.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 RewardCreateManyAndReturnArgs>(args?: SelectSubset<T, RewardCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "createManyAndReturn">>
+
+    /**
+     * Delete a Reward.
+     * @param {RewardDeleteArgs} args - Arguments to delete one Reward.
+     * @example
+     * // Delete one Reward
+     * const Reward = await prisma.reward.delete({
+     *   where: {
+     *     // ... filter to delete one Reward
+     *   }
+     * })
+     * 
+     */
+    delete<T extends RewardDeleteArgs>(args: SelectSubset<T, RewardDeleteArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "delete">, never, ExtArgs>
+
+    /**
+     * Update one Reward.
+     * @param {RewardUpdateArgs} args - Arguments to update one Reward.
+     * @example
+     * // Update one Reward
+     * const reward = await prisma.reward.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends RewardUpdateArgs>(args: SelectSubset<T, RewardUpdateArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "update">, never, ExtArgs>
+
+    /**
+     * Delete zero or more Rewards.
+     * @param {RewardDeleteManyArgs} args - Arguments to filter Rewards to delete.
+     * @example
+     * // Delete a few Rewards
+     * const { count } = await prisma.reward.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends RewardDeleteManyArgs>(args?: SelectSubset<T, RewardDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more Rewards.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RewardUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many Rewards
+     * const reward = await prisma.reward.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends RewardUpdateManyArgs>(args: SelectSubset<T, RewardUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create or update one Reward.
+     * @param {RewardUpsertArgs} args - Arguments to update or create a Reward.
+     * @example
+     * // Update or create a Reward
+     * const reward = await prisma.reward.upsert({
+     *   create: {
+     *     // ... data to create a Reward
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the Reward we want to update
+     *   }
+     * })
+     */
+    upsert<T extends RewardUpsertArgs>(args: SelectSubset<T, RewardUpsertArgs<ExtArgs>>): Prisma__RewardClient<$Result.GetResult<Prisma.$RewardPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
+
+
+    /**
+     * Count the number of Rewards.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RewardCountArgs} args - Arguments to filter Rewards to count.
+     * @example
+     * // Count the number of Rewards
+     * const count = await prisma.reward.count({
+     *   where: {
+     *     // ... the filter for the Rewards we want to count
+     *   }
+     * })
+    **/
+    count<T extends RewardCountArgs>(
+      args?: Subset<T, RewardCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], RewardCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a Reward.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RewardAggregateArgs} 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 RewardAggregateArgs>(args: Subset<T, RewardAggregateArgs>): Prisma.PrismaPromise<GetRewardAggregateType<T>>
+
+    /**
+     * Group by Reward.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RewardGroupByArgs} 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 RewardGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: RewardGroupByArgs['orderBy'] }
+        : { orderBy?: RewardGroupByArgs['orderBy'] },
       OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
       ByFields extends MaybeTupleToUnion<T['by']>,
       ByValid extends Has<ByFields, OrderFields>,
@@ -26057,6 +27160,7 @@ export namespace Prisma {
 
 
   export const UserComputedValueScalarFieldEnum: {
+    id: 'id',
     campaignId: 'campaignId',
     address: 'address',
     reason: 'reason',
@@ -26197,12 +27301,22 @@ export namespace Prisma {
 
   export const UserScalarFieldEnum: {
     address: 'address',
-    tags: 'tags'
+    tags: 'tags',
+    creatorId: 'creatorId'
   };
 
   export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
 
 
+  export const CreatorScalarFieldEnum: {
+    id: 'id',
+    icon: 'icon',
+    name: 'name'
+  };
+
+  export type CreatorScalarFieldEnum = (typeof CreatorScalarFieldEnum)[keyof typeof CreatorScalarFieldEnum]
+
+
   export const RewardScalarFieldEnum: {
     id: 'id',
     root: 'root',
@@ -26467,12 +27581,22 @@ export namespace Prisma {
 
   export const UserOrderByRelevanceFieldEnum: {
     address: 'address',
-    tags: 'tags'
+    tags: 'tags',
+    creatorId: 'creatorId'
   };
 
   export type UserOrderByRelevanceFieldEnum = (typeof UserOrderByRelevanceFieldEnum)[keyof typeof UserOrderByRelevanceFieldEnum]
 
 
+  export const CreatorOrderByRelevanceFieldEnum: {
+    id: 'id',
+    icon: 'icon',
+    name: 'name'
+  };
+
+  export type CreatorOrderByRelevanceFieldEnum = (typeof CreatorOrderByRelevanceFieldEnum)[keyof typeof CreatorOrderByRelevanceFieldEnum]
+
+
   export const RewardOrderByRelevanceFieldEnum: {
     id: 'id',
     root: 'root',
@@ -26988,6 +28112,7 @@ export namespace Prisma {
     AND?: UserComputedValueWhereInput | UserComputedValueWhereInput[]
     OR?: UserComputedValueWhereInput[]
     NOT?: UserComputedValueWhereInput | UserComputedValueWhereInput[]
+    id?: IntFilter<"UserComputedValue"> | number
     campaignId?: StringFilter<"UserComputedValue"> | string
     address?: StringFilter<"UserComputedValue"> | string
     reason?: StringFilter<"UserComputedValue"> | string
@@ -26997,6 +28122,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueOrderByWithRelationInput = {
+    id?: SortOrder
     campaignId?: SortOrder
     address?: SortOrder
     reason?: SortOrder
@@ -27007,19 +28133,21 @@ export namespace Prisma {
   }
 
   export type UserComputedValueWhereUniqueInput = Prisma.AtLeast<{
-    campaignId?: string
+    id?: number
     campaignId_address_reason?: UserComputedValueCampaignIdAddressReasonCompoundUniqueInput
     AND?: UserComputedValueWhereInput | UserComputedValueWhereInput[]
     OR?: UserComputedValueWhereInput[]
     NOT?: UserComputedValueWhereInput | UserComputedValueWhereInput[]
+    campaignId?: StringFilter<"UserComputedValue"> | string
     address?: StringFilter<"UserComputedValue"> | string
     reason?: StringFilter<"UserComputedValue"> | string
     boost?: FloatNullableFilter<"UserComputedValue"> | number | null
     Campaign?: XOR<CampaignScalarRelationFilter, CampaignWhereInput>
     User?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
-  }, "campaignId" | "campaignId_address_reason">
+  }, "id" | "campaignId_address_reason">
 
   export type UserComputedValueOrderByWithAggregationInput = {
+    id?: SortOrder
     campaignId?: SortOrder
     address?: SortOrder
     reason?: SortOrder
@@ -27035,6 +28163,7 @@ export namespace Prisma {
     AND?: UserComputedValueScalarWhereWithAggregatesInput | UserComputedValueScalarWhereWithAggregatesInput[]
     OR?: UserComputedValueScalarWhereWithAggregatesInput[]
     NOT?: UserComputedValueScalarWhereWithAggregatesInput | UserComputedValueScalarWhereWithAggregatesInput[]
+    id?: IntWithAggregatesFilter<"UserComputedValue"> | number
     campaignId?: StringWithAggregatesFilter<"UserComputedValue"> | string
     address?: StringWithAggregatesFilter<"UserComputedValue"> | string
     reason?: StringWithAggregatesFilter<"UserComputedValue"> | string
@@ -27804,19 +28933,23 @@ export namespace Prisma {
     NOT?: UserWhereInput | UserWhereInput[]
     address?: StringFilter<"User"> | string
     tags?: StringNullableListFilter<"User">
+    creatorId?: StringNullableFilter<"User"> | string | null
     Rewards?: RewardListRelationFilter
     Blacklist?: BlacklistListRelationFilter
     CampaignsCreated?: CampaignListRelationFilter
     UserComputedValue?: UserComputedValueListRelationFilter
+    Creator?: XOR<CreatorNullableScalarRelationFilter, CreatorWhereInput> | null
   }
 
   export type UserOrderByWithRelationInput = {
     address?: SortOrder
     tags?: SortOrder
+    creatorId?: SortOrderInput | SortOrder
     Rewards?: RewardOrderByRelationAggregateInput
     Blacklist?: BlacklistOrderByRelationAggregateInput
     CampaignsCreated?: CampaignOrderByRelationAggregateInput
     UserComputedValue?: UserComputedValueOrderByRelationAggregateInput
+    Creator?: CreatorOrderByWithRelationInput
     _relevance?: UserOrderByRelevanceInput
   }
 
@@ -27826,15 +28959,18 @@ export namespace Prisma {
     OR?: UserWhereInput[]
     NOT?: UserWhereInput | UserWhereInput[]
     tags?: StringNullableListFilter<"User">
+    creatorId?: StringNullableFilter<"User"> | string | null
     Rewards?: RewardListRelationFilter
     Blacklist?: BlacklistListRelationFilter
     CampaignsCreated?: CampaignListRelationFilter
     UserComputedValue?: UserComputedValueListRelationFilter
+    Creator?: XOR<CreatorNullableScalarRelationFilter, CreatorWhereInput> | null
   }, "address">
 
   export type UserOrderByWithAggregationInput = {
     address?: SortOrder
     tags?: SortOrder
+    creatorId?: SortOrderInput | SortOrder
     _count?: UserCountOrderByAggregateInput
     _max?: UserMaxOrderByAggregateInput
     _min?: UserMinOrderByAggregateInput
@@ -27846,6 +28982,53 @@ export namespace Prisma {
     NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
     address?: StringWithAggregatesFilter<"User"> | string
     tags?: StringNullableListFilter<"User">
+    creatorId?: StringNullableWithAggregatesFilter<"User"> | string | null
+  }
+
+  export type CreatorWhereInput = {
+    AND?: CreatorWhereInput | CreatorWhereInput[]
+    OR?: CreatorWhereInput[]
+    NOT?: CreatorWhereInput | CreatorWhereInput[]
+    id?: StringFilter<"Creator"> | string
+    icon?: StringNullableFilter<"Creator"> | string | null
+    name?: StringFilter<"Creator"> | string
+    Users?: UserListRelationFilter
+  }
+
+  export type CreatorOrderByWithRelationInput = {
+    id?: SortOrder
+    icon?: SortOrderInput | SortOrder
+    name?: SortOrder
+    Users?: UserOrderByRelationAggregateInput
+    _relevance?: CreatorOrderByRelevanceInput
+  }
+
+  export type CreatorWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    AND?: CreatorWhereInput | CreatorWhereInput[]
+    OR?: CreatorWhereInput[]
+    NOT?: CreatorWhereInput | CreatorWhereInput[]
+    icon?: StringNullableFilter<"Creator"> | string | null
+    name?: StringFilter<"Creator"> | string
+    Users?: UserListRelationFilter
+  }, "id">
+
+  export type CreatorOrderByWithAggregationInput = {
+    id?: SortOrder
+    icon?: SortOrderInput | SortOrder
+    name?: SortOrder
+    _count?: CreatorCountOrderByAggregateInput
+    _max?: CreatorMaxOrderByAggregateInput
+    _min?: CreatorMinOrderByAggregateInput
+  }
+
+  export type CreatorScalarWhereWithAggregatesInput = {
+    AND?: CreatorScalarWhereWithAggregatesInput | CreatorScalarWhereWithAggregatesInput[]
+    OR?: CreatorScalarWhereWithAggregatesInput[]
+    NOT?: CreatorScalarWhereWithAggregatesInput | CreatorScalarWhereWithAggregatesInput[]
+    id?: StringWithAggregatesFilter<"Creator"> | string
+    icon?: StringNullableWithAggregatesFilter<"Creator"> | string | null
+    name?: StringWithAggregatesFilter<"Creator"> | string
   }
 
   export type RewardWhereInput = {
@@ -28527,6 +29710,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedCreateInput = {
+    id?: number
     campaignId: string
     address: string
     reason: string
@@ -28541,6 +29725,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedUpdateInput = {
+    id?: IntFieldUpdateOperationsInput | number
     campaignId?: StringFieldUpdateOperationsInput | string
     address?: StringFieldUpdateOperationsInput | string
     reason?: StringFieldUpdateOperationsInput | string
@@ -28548,6 +29733,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueCreateManyInput = {
+    id?: number
     campaignId: string
     address: string
     reason: string
@@ -28560,6 +29746,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedUpdateManyInput = {
+    id?: IntFieldUpdateOperationsInput | number
     campaignId?: StringFieldUpdateOperationsInput | string
     address?: StringFieldUpdateOperationsInput | string
     reason?: StringFieldUpdateOperationsInput | string
@@ -29325,11 +30512,13 @@ export namespace Prisma {
     Blacklist?: BlacklistCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignCreateNestedManyWithoutCreatorInput
     UserComputedValue?: UserComputedValueCreateNestedManyWithoutUserInput
+    Creator?: CreatorCreateNestedOneWithoutUsersInput
   }
 
   export type UserUncheckedCreateInput = {
     address: string
     tags?: UserCreatetagsInput | string[]
+    creatorId?: string | null
     Rewards?: RewardUncheckedCreateNestedManyWithoutUserInput
     Blacklist?: BlacklistUncheckedCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignUncheckedCreateNestedManyWithoutCreatorInput
@@ -29343,11 +30532,13 @@ export namespace Prisma {
     Blacklist?: BlacklistUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUpdateManyWithoutCreatorNestedInput
     UserComputedValue?: UserComputedValueUpdateManyWithoutUserNestedInput
+    Creator?: CreatorUpdateOneWithoutUsersNestedInput
   }
 
   export type UserUncheckedUpdateInput = {
     address?: StringFieldUpdateOperationsInput | string
     tags?: UserUpdatetagsInput | string[]
+    creatorId?: NullableStringFieldUpdateOperationsInput | string | null
     Rewards?: RewardUncheckedUpdateManyWithoutUserNestedInput
     Blacklist?: BlacklistUncheckedUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUncheckedUpdateManyWithoutCreatorNestedInput
@@ -29357,6 +30548,7 @@ export namespace Prisma {
   export type UserCreateManyInput = {
     address: string
     tags?: UserCreatetagsInput | string[]
+    creatorId?: string | null
   }
 
   export type UserUpdateManyMutationInput = {
@@ -29367,6 +30559,53 @@ export namespace Prisma {
   export type UserUncheckedUpdateManyInput = {
     address?: StringFieldUpdateOperationsInput | string
     tags?: UserUpdatetagsInput | string[]
+    creatorId?: NullableStringFieldUpdateOperationsInput | string | null
+  }
+
+  export type CreatorCreateInput = {
+    id: string
+    icon?: string | null
+    name: string
+    Users?: UserCreateNestedManyWithoutCreatorInput
+  }
+
+  export type CreatorUncheckedCreateInput = {
+    id: string
+    icon?: string | null
+    name: string
+    Users?: UserUncheckedCreateNestedManyWithoutCreatorInput
+  }
+
+  export type CreatorUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    icon?: NullableStringFieldUpdateOperationsInput | string | null
+    name?: StringFieldUpdateOperationsInput | string
+    Users?: UserUpdateManyWithoutCreatorNestedInput
+  }
+
+  export type CreatorUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    icon?: NullableStringFieldUpdateOperationsInput | string | null
+    name?: StringFieldUpdateOperationsInput | string
+    Users?: UserUncheckedUpdateManyWithoutCreatorNestedInput
+  }
+
+  export type CreatorCreateManyInput = {
+    id: string
+    icon?: string | null
+    name: string
+  }
+
+  export type CreatorUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    icon?: NullableStringFieldUpdateOperationsInput | string | null
+    name?: StringFieldUpdateOperationsInput | string
+  }
+
+  export type CreatorUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    icon?: NullableStringFieldUpdateOperationsInput | string | null
+    name?: StringFieldUpdateOperationsInput | string
   }
 
   export type RewardCreateInput = {
@@ -30254,6 +31493,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueCountOrderByAggregateInput = {
+    id?: SortOrder
     campaignId?: SortOrder
     address?: SortOrder
     reason?: SortOrder
@@ -30261,10 +31501,12 @@ export namespace Prisma {
   }
 
   export type UserComputedValueAvgOrderByAggregateInput = {
+    id?: SortOrder
     boost?: SortOrder
   }
 
   export type UserComputedValueMaxOrderByAggregateInput = {
+    id?: SortOrder
     campaignId?: SortOrder
     address?: SortOrder
     reason?: SortOrder
@@ -30272,6 +31514,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueMinOrderByAggregateInput = {
+    id?: SortOrder
     campaignId?: SortOrder
     address?: SortOrder
     reason?: SortOrder
@@ -30279,6 +31522,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueSumOrderByAggregateInput = {
+    id?: SortOrder
     boost?: SortOrder
   }
 
@@ -31093,6 +32337,11 @@ export namespace Prisma {
     value?: SortOrder
   }
 
+  export type CreatorNullableScalarRelationFilter = {
+    is?: CreatorWhereInput | null
+    isNot?: CreatorWhereInput | null
+  }
+
   export type UserOrderByRelevanceInput = {
     fields: UserOrderByRelevanceFieldEnum | UserOrderByRelevanceFieldEnum[]
     sort: SortOrder
@@ -31102,14 +32351,51 @@ export namespace Prisma {
   export type UserCountOrderByAggregateInput = {
     address?: SortOrder
     tags?: SortOrder
+    creatorId?: SortOrder
   }
 
   export type UserMaxOrderByAggregateInput = {
     address?: SortOrder
+    creatorId?: SortOrder
   }
 
   export type UserMinOrderByAggregateInput = {
     address?: SortOrder
+    creatorId?: SortOrder
+  }
+
+  export type UserListRelationFilter = {
+    every?: UserWhereInput
+    some?: UserWhereInput
+    none?: UserWhereInput
+  }
+
+  export type UserOrderByRelationAggregateInput = {
+    _count?: SortOrder
+  }
+
+  export type CreatorOrderByRelevanceInput = {
+    fields: CreatorOrderByRelevanceFieldEnum | CreatorOrderByRelevanceFieldEnum[]
+    sort: SortOrder
+    search: string
+  }
+
+  export type CreatorCountOrderByAggregateInput = {
+    id?: SortOrder
+    icon?: SortOrder
+    name?: SortOrder
+  }
+
+  export type CreatorMaxOrderByAggregateInput = {
+    id?: SortOrder
+    icon?: SortOrder
+    name?: SortOrder
+  }
+
+  export type CreatorMinOrderByAggregateInput = {
+    id?: SortOrder
+    icon?: SortOrder
+    name?: SortOrder
   }
 
   export type MerklRootScalarRelationFilter = {
@@ -33152,6 +34438,12 @@ export namespace Prisma {
     connect?: UserComputedValueWhereUniqueInput | UserComputedValueWhereUniqueInput[]
   }
 
+  export type CreatorCreateNestedOneWithoutUsersInput = {
+    create?: XOR<CreatorCreateWithoutUsersInput, CreatorUncheckedCreateWithoutUsersInput>
+    connectOrCreate?: CreatorCreateOrConnectWithoutUsersInput
+    connect?: CreatorWhereUniqueInput
+  }
+
   export type RewardUncheckedCreateNestedManyWithoutUserInput = {
     create?: XOR<RewardCreateWithoutUserInput, RewardUncheckedCreateWithoutUserInput> | RewardCreateWithoutUserInput[] | RewardUncheckedCreateWithoutUserInput[]
     connectOrCreate?: RewardCreateOrConnectWithoutUserInput | RewardCreateOrConnectWithoutUserInput[]
@@ -33241,6 +34533,16 @@ export namespace Prisma {
     deleteMany?: UserComputedValueScalarWhereInput | UserComputedValueScalarWhereInput[]
   }
 
+  export type CreatorUpdateOneWithoutUsersNestedInput = {
+    create?: XOR<CreatorCreateWithoutUsersInput, CreatorUncheckedCreateWithoutUsersInput>
+    connectOrCreate?: CreatorCreateOrConnectWithoutUsersInput
+    upsert?: CreatorUpsertWithoutUsersInput
+    disconnect?: CreatorWhereInput | boolean
+    delete?: CreatorWhereInput | boolean
+    connect?: CreatorWhereUniqueInput
+    update?: XOR<XOR<CreatorUpdateToOneWithWhereWithoutUsersInput, CreatorUpdateWithoutUsersInput>, CreatorUncheckedUpdateWithoutUsersInput>
+  }
+
   export type RewardUncheckedUpdateManyWithoutUserNestedInput = {
     create?: XOR<RewardCreateWithoutUserInput, RewardUncheckedCreateWithoutUserInput> | RewardCreateWithoutUserInput[] | RewardUncheckedCreateWithoutUserInput[]
     connectOrCreate?: RewardCreateOrConnectWithoutUserInput | RewardCreateOrConnectWithoutUserInput[]
@@ -33297,6 +34599,48 @@ export namespace Prisma {
     deleteMany?: UserComputedValueScalarWhereInput | UserComputedValueScalarWhereInput[]
   }
 
+  export type UserCreateNestedManyWithoutCreatorInput = {
+    create?: XOR<UserCreateWithoutCreatorInput, UserUncheckedCreateWithoutCreatorInput> | UserCreateWithoutCreatorInput[] | UserUncheckedCreateWithoutCreatorInput[]
+    connectOrCreate?: UserCreateOrConnectWithoutCreatorInput | UserCreateOrConnectWithoutCreatorInput[]
+    createMany?: UserCreateManyCreatorInputEnvelope
+    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
+  }
+
+  export type UserUncheckedCreateNestedManyWithoutCreatorInput = {
+    create?: XOR<UserCreateWithoutCreatorInput, UserUncheckedCreateWithoutCreatorInput> | UserCreateWithoutCreatorInput[] | UserUncheckedCreateWithoutCreatorInput[]
+    connectOrCreate?: UserCreateOrConnectWithoutCreatorInput | UserCreateOrConnectWithoutCreatorInput[]
+    createMany?: UserCreateManyCreatorInputEnvelope
+    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
+  }
+
+  export type UserUpdateManyWithoutCreatorNestedInput = {
+    create?: XOR<UserCreateWithoutCreatorInput, UserUncheckedCreateWithoutCreatorInput> | UserCreateWithoutCreatorInput[] | UserUncheckedCreateWithoutCreatorInput[]
+    connectOrCreate?: UserCreateOrConnectWithoutCreatorInput | UserCreateOrConnectWithoutCreatorInput[]
+    upsert?: UserUpsertWithWhereUniqueWithoutCreatorInput | UserUpsertWithWhereUniqueWithoutCreatorInput[]
+    createMany?: UserCreateManyCreatorInputEnvelope
+    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    update?: UserUpdateWithWhereUniqueWithoutCreatorInput | UserUpdateWithWhereUniqueWithoutCreatorInput[]
+    updateMany?: UserUpdateManyWithWhereWithoutCreatorInput | UserUpdateManyWithWhereWithoutCreatorInput[]
+    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
+  }
+
+  export type UserUncheckedUpdateManyWithoutCreatorNestedInput = {
+    create?: XOR<UserCreateWithoutCreatorInput, UserUncheckedCreateWithoutCreatorInput> | UserCreateWithoutCreatorInput[] | UserUncheckedCreateWithoutCreatorInput[]
+    connectOrCreate?: UserCreateOrConnectWithoutCreatorInput | UserCreateOrConnectWithoutCreatorInput[]
+    upsert?: UserUpsertWithWhereUniqueWithoutCreatorInput | UserUpsertWithWhereUniqueWithoutCreatorInput[]
+    createMany?: UserCreateManyCreatorInputEnvelope
+    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
+    update?: UserUpdateWithWhereUniqueWithoutCreatorInput | UserUpdateWithWhereUniqueWithoutCreatorInput[]
+    updateMany?: UserUpdateManyWithWhereWithoutCreatorInput | UserUpdateManyWithWhereWithoutCreatorInput[]
+    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
+  }
+
   export type RewardCreateproofsInput = {
     set: string[]
   }
@@ -34197,11 +35541,13 @@ export namespace Prisma {
     Rewards?: RewardCreateNestedManyWithoutUserInput
     Blacklist?: BlacklistCreateNestedManyWithoutUserInput
     UserComputedValue?: UserComputedValueCreateNestedManyWithoutUserInput
+    Creator?: CreatorCreateNestedOneWithoutUsersInput
   }
 
   export type UserUncheckedCreateWithoutCampaignsCreatedInput = {
     address: string
     tags?: UserCreatetagsInput | string[]
+    creatorId?: string | null
     Rewards?: RewardUncheckedCreateNestedManyWithoutUserInput
     Blacklist?: BlacklistUncheckedCreateNestedManyWithoutUserInput
     UserComputedValue?: UserComputedValueUncheckedCreateNestedManyWithoutUserInput
@@ -34267,6 +35613,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedCreateWithoutCampaignInput = {
+    id?: number
     address: string
     reason: string
     boost?: number | null
@@ -34531,11 +35878,13 @@ export namespace Prisma {
     Rewards?: RewardUpdateManyWithoutUserNestedInput
     Blacklist?: BlacklistUpdateManyWithoutUserNestedInput
     UserComputedValue?: UserComputedValueUpdateManyWithoutUserNestedInput
+    Creator?: CreatorUpdateOneWithoutUsersNestedInput
   }
 
   export type UserUncheckedUpdateWithoutCampaignsCreatedInput = {
     address?: StringFieldUpdateOperationsInput | string
     tags?: UserUpdatetagsInput | string[]
+    creatorId?: NullableStringFieldUpdateOperationsInput | string | null
     Rewards?: RewardUncheckedUpdateManyWithoutUserNestedInput
     Blacklist?: BlacklistUncheckedUpdateManyWithoutUserNestedInput
     UserComputedValue?: UserComputedValueUncheckedUpdateManyWithoutUserNestedInput
@@ -34615,6 +35964,7 @@ export namespace Prisma {
     AND?: UserComputedValueScalarWhereInput | UserComputedValueScalarWhereInput[]
     OR?: UserComputedValueScalarWhereInput[]
     NOT?: UserComputedValueScalarWhereInput | UserComputedValueScalarWhereInput[]
+    id?: IntFilter<"UserComputedValue"> | number
     campaignId?: StringFilter<"UserComputedValue"> | string
     address?: StringFilter<"UserComputedValue"> | string
     reason?: StringFilter<"UserComputedValue"> | string
@@ -34864,11 +36214,13 @@ export namespace Prisma {
     Rewards?: RewardCreateNestedManyWithoutUserInput
     Blacklist?: BlacklistCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignCreateNestedManyWithoutCreatorInput
+    Creator?: CreatorCreateNestedOneWithoutUsersInput
   }
 
   export type UserUncheckedCreateWithoutUserComputedValueInput = {
     address: string
     tags?: UserCreatetagsInput | string[]
+    creatorId?: string | null
     Rewards?: RewardUncheckedCreateNestedManyWithoutUserInput
     Blacklist?: BlacklistUncheckedCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignUncheckedCreateNestedManyWithoutCreatorInput
@@ -34947,11 +36299,13 @@ export namespace Prisma {
     Rewards?: RewardUpdateManyWithoutUserNestedInput
     Blacklist?: BlacklistUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUpdateManyWithoutCreatorNestedInput
+    Creator?: CreatorUpdateOneWithoutUsersNestedInput
   }
 
   export type UserUncheckedUpdateWithoutUserComputedValueInput = {
     address?: StringFieldUpdateOperationsInput | string
     tags?: UserUpdatetagsInput | string[]
+    creatorId?: NullableStringFieldUpdateOperationsInput | string | null
     Rewards?: RewardUncheckedUpdateManyWithoutUserNestedInput
     Blacklist?: BlacklistUncheckedUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUncheckedUpdateManyWithoutCreatorNestedInput
@@ -37335,6 +38689,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedCreateWithoutUserInput = {
+    id?: number
     campaignId: string
     reason: string
     boost?: number | null
@@ -37350,6 +38705,23 @@ export namespace Prisma {
     skipDuplicates?: boolean
   }
 
+  export type CreatorCreateWithoutUsersInput = {
+    id: string
+    icon?: string | null
+    name: string
+  }
+
+  export type CreatorUncheckedCreateWithoutUsersInput = {
+    id: string
+    icon?: string | null
+    name: string
+  }
+
+  export type CreatorCreateOrConnectWithoutUsersInput = {
+    where: CreatorWhereUniqueInput
+    create: XOR<CreatorCreateWithoutUsersInput, CreatorUncheckedCreateWithoutUsersInput>
+  }
+
   export type RewardUpsertWithWhereUniqueWithoutUserInput = {
     where: RewardWhereUniqueInput
     update: XOR<RewardUpdateWithoutUserInput, RewardUncheckedUpdateWithoutUserInput>
@@ -37414,6 +38786,82 @@ export namespace Prisma {
     data: XOR<UserComputedValueUpdateManyMutationInput, UserComputedValueUncheckedUpdateManyWithoutUserInput>
   }
 
+  export type CreatorUpsertWithoutUsersInput = {
+    update: XOR<CreatorUpdateWithoutUsersInput, CreatorUncheckedUpdateWithoutUsersInput>
+    create: XOR<CreatorCreateWithoutUsersInput, CreatorUncheckedCreateWithoutUsersInput>
+    where?: CreatorWhereInput
+  }
+
+  export type CreatorUpdateToOneWithWhereWithoutUsersInput = {
+    where?: CreatorWhereInput
+    data: XOR<CreatorUpdateWithoutUsersInput, CreatorUncheckedUpdateWithoutUsersInput>
+  }
+
+  export type CreatorUpdateWithoutUsersInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    icon?: NullableStringFieldUpdateOperationsInput | string | null
+    name?: StringFieldUpdateOperationsInput | string
+  }
+
+  export type CreatorUncheckedUpdateWithoutUsersInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    icon?: NullableStringFieldUpdateOperationsInput | string | null
+    name?: StringFieldUpdateOperationsInput | string
+  }
+
+  export type UserCreateWithoutCreatorInput = {
+    address: string
+    tags?: UserCreatetagsInput | string[]
+    Rewards?: RewardCreateNestedManyWithoutUserInput
+    Blacklist?: BlacklistCreateNestedManyWithoutUserInput
+    CampaignsCreated?: CampaignCreateNestedManyWithoutCreatorInput
+    UserComputedValue?: UserComputedValueCreateNestedManyWithoutUserInput
+  }
+
+  export type UserUncheckedCreateWithoutCreatorInput = {
+    address: string
+    tags?: UserCreatetagsInput | string[]
+    Rewards?: RewardUncheckedCreateNestedManyWithoutUserInput
+    Blacklist?: BlacklistUncheckedCreateNestedManyWithoutUserInput
+    CampaignsCreated?: CampaignUncheckedCreateNestedManyWithoutCreatorInput
+    UserComputedValue?: UserComputedValueUncheckedCreateNestedManyWithoutUserInput
+  }
+
+  export type UserCreateOrConnectWithoutCreatorInput = {
+    where: UserWhereUniqueInput
+    create: XOR<UserCreateWithoutCreatorInput, UserUncheckedCreateWithoutCreatorInput>
+  }
+
+  export type UserCreateManyCreatorInputEnvelope = {
+    data: UserCreateManyCreatorInput | UserCreateManyCreatorInput[]
+    skipDuplicates?: boolean
+  }
+
+  export type UserUpsertWithWhereUniqueWithoutCreatorInput = {
+    where: UserWhereUniqueInput
+    update: XOR<UserUpdateWithoutCreatorInput, UserUncheckedUpdateWithoutCreatorInput>
+    create: XOR<UserCreateWithoutCreatorInput, UserUncheckedCreateWithoutCreatorInput>
+  }
+
+  export type UserUpdateWithWhereUniqueWithoutCreatorInput = {
+    where: UserWhereUniqueInput
+    data: XOR<UserUpdateWithoutCreatorInput, UserUncheckedUpdateWithoutCreatorInput>
+  }
+
+  export type UserUpdateManyWithWhereWithoutCreatorInput = {
+    where: UserScalarWhereInput
+    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutCreatorInput>
+  }
+
+  export type UserScalarWhereInput = {
+    AND?: UserScalarWhereInput | UserScalarWhereInput[]
+    OR?: UserScalarWhereInput[]
+    NOT?: UserScalarWhereInput | UserScalarWhereInput[]
+    address?: StringFilter<"User"> | string
+    tags?: StringNullableListFilter<"User">
+    creatorId?: StringNullableFilter<"User"> | string | null
+  }
+
   export type MerklRootCreateWithoutRewardsInput = {
     root: string
     epoch: number
@@ -37439,11 +38887,13 @@ export namespace Prisma {
     Blacklist?: BlacklistCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignCreateNestedManyWithoutCreatorInput
     UserComputedValue?: UserComputedValueCreateNestedManyWithoutUserInput
+    Creator?: CreatorCreateNestedOneWithoutUsersInput
   }
 
   export type UserUncheckedCreateWithoutRewardsInput = {
     address: string
     tags?: UserCreatetagsInput | string[]
+    creatorId?: string | null
     Blacklist?: BlacklistUncheckedCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignUncheckedCreateNestedManyWithoutCreatorInput
     UserComputedValue?: UserComputedValueUncheckedCreateNestedManyWithoutUserInput
@@ -37570,11 +39020,13 @@ export namespace Prisma {
     Blacklist?: BlacklistUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUpdateManyWithoutCreatorNestedInput
     UserComputedValue?: UserComputedValueUpdateManyWithoutUserNestedInput
+    Creator?: CreatorUpdateOneWithoutUsersNestedInput
   }
 
   export type UserUncheckedUpdateWithoutRewardsInput = {
     address?: StringFieldUpdateOperationsInput | string
     tags?: UserUpdatetagsInput | string[]
+    creatorId?: NullableStringFieldUpdateOperationsInput | string | null
     Blacklist?: BlacklistUncheckedUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUncheckedUpdateManyWithoutCreatorNestedInput
     UserComputedValue?: UserComputedValueUncheckedUpdateManyWithoutUserNestedInput
@@ -38012,11 +39464,13 @@ export namespace Prisma {
     Rewards?: RewardCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignCreateNestedManyWithoutCreatorInput
     UserComputedValue?: UserComputedValueCreateNestedManyWithoutUserInput
+    Creator?: CreatorCreateNestedOneWithoutUsersInput
   }
 
   export type UserUncheckedCreateWithoutBlacklistInput = {
     address: string
     tags?: UserCreatetagsInput | string[]
+    creatorId?: string | null
     Rewards?: RewardUncheckedCreateNestedManyWithoutUserInput
     CampaignsCreated?: CampaignUncheckedCreateNestedManyWithoutCreatorInput
     UserComputedValue?: UserComputedValueUncheckedCreateNestedManyWithoutUserInput
@@ -38081,11 +39535,13 @@ export namespace Prisma {
     Rewards?: RewardUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUpdateManyWithoutCreatorNestedInput
     UserComputedValue?: UserComputedValueUpdateManyWithoutUserNestedInput
+    Creator?: CreatorUpdateOneWithoutUsersNestedInput
   }
 
   export type UserUncheckedUpdateWithoutBlacklistInput = {
     address?: StringFieldUpdateOperationsInput | string
     tags?: UserUpdatetagsInput | string[]
+    creatorId?: NullableStringFieldUpdateOperationsInput | string | null
     Rewards?: RewardUncheckedUpdateManyWithoutUserNestedInput
     CampaignsCreated?: CampaignUncheckedUpdateManyWithoutCreatorNestedInput
     UserComputedValue?: UserComputedValueUncheckedUpdateManyWithoutUserNestedInput
@@ -38368,6 +39824,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueCreateManyCampaignInput = {
+    id?: number
     address: string
     reason: string
     boost?: number | null
@@ -38474,12 +39931,14 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedUpdateWithoutCampaignInput = {
+    id?: IntFieldUpdateOperationsInput | number
     address?: StringFieldUpdateOperationsInput | string
     reason?: StringFieldUpdateOperationsInput | string
     boost?: NullableFloatFieldUpdateOperationsInput | number | null
   }
 
   export type UserComputedValueUncheckedUpdateManyWithoutCampaignInput = {
+    id?: IntFieldUpdateOperationsInput | number
     address?: StringFieldUpdateOperationsInput | string
     reason?: StringFieldUpdateOperationsInput | string
     boost?: NullableFloatFieldUpdateOperationsInput | number | null
@@ -39672,6 +41131,7 @@ export namespace Prisma {
   }
 
   export type UserComputedValueCreateManyUserInput = {
+    id?: number
     campaignId: string
     reason: string
     boost?: number | null
@@ -39795,17 +41255,47 @@ export namespace Prisma {
   }
 
   export type UserComputedValueUncheckedUpdateWithoutUserInput = {
+    id?: IntFieldUpdateOperationsInput | number
     campaignId?: StringFieldUpdateOperationsInput | string
     reason?: StringFieldUpdateOperationsInput | string
     boost?: NullableFloatFieldUpdateOperationsInput | number | null
   }
 
   export type UserComputedValueUncheckedUpdateManyWithoutUserInput = {
+    id?: IntFieldUpdateOperationsInput | number
     campaignId?: StringFieldUpdateOperationsInput | string
     reason?: StringFieldUpdateOperationsInput | string
     boost?: NullableFloatFieldUpdateOperationsInput | number | null
   }
 
+  export type UserCreateManyCreatorInput = {
+    address: string
+    tags?: UserCreatetagsInput | string[]
+  }
+
+  export type UserUpdateWithoutCreatorInput = {
+    address?: StringFieldUpdateOperationsInput | string
+    tags?: UserUpdatetagsInput | string[]
+    Rewards?: RewardUpdateManyWithoutUserNestedInput
+    Blacklist?: BlacklistUpdateManyWithoutUserNestedInput
+    CampaignsCreated?: CampaignUpdateManyWithoutCreatorNestedInput
+    UserComputedValue?: UserComputedValueUpdateManyWithoutUserNestedInput
+  }
+
+  export type UserUncheckedUpdateWithoutCreatorInput = {
+    address?: StringFieldUpdateOperationsInput | string
+    tags?: UserUpdatetagsInput | string[]
+    Rewards?: RewardUncheckedUpdateManyWithoutUserNestedInput
+    Blacklist?: BlacklistUncheckedUpdateManyWithoutUserNestedInput
+    CampaignsCreated?: CampaignUncheckedUpdateManyWithoutCreatorNestedInput
+    UserComputedValue?: UserComputedValueUncheckedUpdateManyWithoutUserNestedInput
+  }
+
+  export type UserUncheckedUpdateManyWithoutCreatorInput = {
+    address?: StringFieldUpdateOperationsInput | string
+    tags?: UserUpdatetagsInput | string[]
+  }
+
   export type RewardBreakdownCreateManyRewardInput = {
     id?: number
     protocolId?: string | null