expo-backend-types 0.32.0-EXPO-315-Marcelo-Tinelli.1 → 0.32.0-EXPO-315-Marcelo-Tinelli.3

package/dist/types/prisma-schema/index.d.ts

@@ -73,6 +73,11 @@ export type Ticket = $Result.DefaultSelection<Prisma.$TicketPayload>
  * 
  */
 export type Enums = $Result.DefaultSelection<Prisma.$EnumsPayload>
+/**
+ * Model EventTicket
+ * 
+ */
+export type EventTicket = $Result.DefaultSelection<Prisma.$EventTicketPayload>
 
 /**
  * Enums
@@ -108,8 +113,8 @@ export type MessageState = (typeof MessageState)[keyof typeof MessageState]
 
 export const TicketType: {
   PARTICIPANT: 'PARTICIPANT',
-  SPECTATOR: 'SPECTATOR',
-  STAFF: 'STAFF'
+  STAFF: 'STAFF',
+  SPECTATOR: 'SPECTATOR'
 };
 
 export type TicketType = (typeof TicketType)[keyof typeof TicketType]
@@ -117,7 +122,8 @@ export type TicketType = (typeof TicketType)[keyof typeof TicketType]
 
 export const TicketStatus: {
   BOOKED: 'BOOKED',
-  PAID: 'PAID'
+  PAID: 'PAID',
+  FREE: 'FREE'
 };
 
 export type TicketStatus = (typeof TicketStatus)[keyof typeof TicketStatus]
@@ -412,6 +418,16 @@ export class PrismaClient<
     * ```
     */
   get enums(): Prisma.EnumsDelegate<ExtArgs>;
+
+  /**
+   * `prisma.eventTicket`: Exposes CRUD operations for the **EventTicket** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more EventTickets
+    * const eventTickets = await prisma.eventTicket.findMany()
+    * ```
+    */
+  get eventTicket(): Prisma.EventTicketDelegate<ExtArgs>;
 }
 
 export namespace Prisma {
@@ -864,7 +880,8 @@ export namespace Prisma {
     Message: 'Message',
     CannedResponse: 'CannedResponse',
     Ticket: 'Ticket',
-    Enums: 'Enums'
+    Enums: 'Enums',
+    EventTicket: 'EventTicket'
   };
 
   export type ModelName = (typeof ModelName)[keyof typeof ModelName]
@@ -880,7 +897,7 @@ export namespace Prisma {
 
   export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
     meta: {
-      modelProps: "account" | "profile" | "location" | "comment" | "tag" | "tagGroup" | "event" | "eventFolder" | "message" | "cannedResponse" | "ticket" | "enums"
+      modelProps: "account" | "profile" | "location" | "comment" | "tag" | "tagGroup" | "event" | "eventFolder" | "message" | "cannedResponse" | "ticket" | "enums" | "eventTicket"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -1724,6 +1741,76 @@ export namespace Prisma {
           }
         }
       }
+      EventTicket: {
+        payload: Prisma.$EventTicketPayload<ExtArgs>
+        fields: Prisma.EventTicketFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.EventTicketFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.EventTicketFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>
+          }
+          findFirst: {
+            args: Prisma.EventTicketFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.EventTicketFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>
+          }
+          findMany: {
+            args: Prisma.EventTicketFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>[]
+          }
+          create: {
+            args: Prisma.EventTicketCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>
+          }
+          createMany: {
+            args: Prisma.EventTicketCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          createManyAndReturn: {
+            args: Prisma.EventTicketCreateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>[]
+          }
+          delete: {
+            args: Prisma.EventTicketDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>
+          }
+          update: {
+            args: Prisma.EventTicketUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>
+          }
+          deleteMany: {
+            args: Prisma.EventTicketDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.EventTicketUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          upsert: {
+            args: Prisma.EventTicketUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$EventTicketPayload>
+          }
+          aggregate: {
+            args: Prisma.EventTicketAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateEventTicket>
+          }
+          groupBy: {
+            args: Prisma.EventTicketGroupByArgs<ExtArgs>
+            result: $Utils.Optional<EventTicketGroupByOutputType>[]
+          }
+          count: {
+            args: Prisma.EventTicketCountArgs<ExtArgs>
+            result: $Utils.Optional<EventTicketCountAggregateOutputType> | number
+          }
+        }
+      }
     }
   } & {
     other: {
@@ -2035,12 +2122,14 @@ export namespace Prisma {
     accounts: number
     profiles: number
     accountsGlobalFilter: number
+    Event: number
   }
 
   export type TagCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     accounts?: boolean | TagCountOutputTypeCountAccountsArgs
     profiles?: boolean | TagCountOutputTypeCountProfilesArgs
     accountsGlobalFilter?: boolean | TagCountOutputTypeCountAccountsGlobalFilterArgs
+    Event?: boolean | TagCountOutputTypeCountEventArgs
   }
 
   // Custom InputTypes
@@ -2075,6 +2164,13 @@ export namespace Prisma {
     where?: AccountWhereInput
   }
 
+  /**
+   * TagCountOutputType without action
+   */
+  export type TagCountOutputTypeCountEventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: EventWhereInput
+  }
+
 
   /**
    * Count Type TagGroupCountOutputType
@@ -2112,13 +2208,17 @@ export namespace Prisma {
    */
 
   export type EventCountOutputType = {
-    subEvents: number
     tickets: number
+    subEvents: number
+    tags: number
+    eventTickets: number
   }
 
   export type EventCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    subEvents?: boolean | EventCountOutputTypeCountSubEventsArgs
     tickets?: boolean | EventCountOutputTypeCountTicketsArgs
+    subEvents?: boolean | EventCountOutputTypeCountSubEventsArgs
+    tags?: boolean | EventCountOutputTypeCountTagsArgs
+    eventTickets?: boolean | EventCountOutputTypeCountEventTicketsArgs
   }
 
   // Custom InputTypes
@@ -2132,6 +2232,13 @@ export namespace Prisma {
     select?: EventCountOutputTypeSelect<ExtArgs> | null
   }
 
+  /**
+   * EventCountOutputType without action
+   */
+  export type EventCountOutputTypeCountTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: TicketWhereInput
+  }
+
   /**
    * EventCountOutputType without action
    */
@@ -2142,8 +2249,15 @@ export namespace Prisma {
   /**
    * EventCountOutputType without action
    */
-  export type EventCountOutputTypeCountTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: TicketWhereInput
+  export type EventCountOutputTypeCountTagsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: TagWhereInput
+  }
+
+  /**
+   * EventCountOutputType without action
+   */
+  export type EventCountOutputTypeCountEventTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: EventTicketWhereInput
   }
 
 
@@ -6719,6 +6833,7 @@ export namespace Prisma {
     accounts?: boolean | Tag$accountsArgs<ExtArgs>
     profiles?: boolean | Tag$profilesArgs<ExtArgs>
     accountsGlobalFilter?: boolean | Tag$accountsGlobalFilterArgs<ExtArgs>
+    Event?: boolean | Tag$EventArgs<ExtArgs>
     _count?: boolean | TagCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["tag"]>
 
@@ -6748,6 +6863,7 @@ export namespace Prisma {
     accounts?: boolean | Tag$accountsArgs<ExtArgs>
     profiles?: boolean | Tag$profilesArgs<ExtArgs>
     accountsGlobalFilter?: boolean | Tag$accountsGlobalFilterArgs<ExtArgs>
+    Event?: boolean | Tag$EventArgs<ExtArgs>
     _count?: boolean | TagCountOutputTypeDefaultArgs<ExtArgs>
   }
   export type TagIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
@@ -6763,6 +6879,7 @@ export namespace Prisma {
       accounts: Prisma.$AccountPayload<ExtArgs>[]
       profiles: Prisma.$ProfilePayload<ExtArgs>[]
       accountsGlobalFilter: Prisma.$AccountPayload<ExtArgs>[]
+      Event: Prisma.$EventPayload<ExtArgs>[]
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
@@ -7141,6 +7258,7 @@ export namespace Prisma {
     accounts<T extends Tag$accountsArgs<ExtArgs> = {}>(args?: Subset<T, Tag$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany"> | Null>
     profiles<T extends Tag$profilesArgs<ExtArgs> = {}>(args?: Subset<T, Tag$profilesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProfilePayload<ExtArgs>, T, "findMany"> | Null>
     accountsGlobalFilter<T extends Tag$accountsGlobalFilterArgs<ExtArgs> = {}>(args?: Subset<T, Tag$accountsGlobalFilterArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany"> | Null>
+    Event<T extends Tag$EventArgs<ExtArgs> = {}>(args?: Subset<T, Tag$EventArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<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.
@@ -7583,6 +7701,26 @@ export namespace Prisma {
     distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
   }
 
+  /**
+   * Tag.Event
+   */
+  export type Tag$EventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Event
+     */
+    select?: EventSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventInclude<ExtArgs> | null
+    where?: EventWhereInput
+    orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
+    cursor?: EventWhereUniqueInput
+    take?: number
+    skip?: number
+    distinct?: EventScalarFieldEnum | EventScalarFieldEnum[]
+  }
+
   /**
    * Tag without action
    */
@@ -8572,11 +8710,14 @@ export namespace Prisma {
     id: string | null
     name: string | null
     date: Date | null
+    startingDate: Date | null
+    endingDate: Date | null
     location: string | null
     folderId: string | null
     tagAssistedId: string | null
     tagConfirmedId: string | null
     supraEventId: string | null
+    active: boolean | null
     created_at: Date | null
     updated_at: Date | null
   }
@@ -8585,11 +8726,14 @@ export namespace Prisma {
     id: string | null
     name: string | null
     date: Date | null
+    startingDate: Date | null
+    endingDate: Date | null
     location: string | null
     folderId: string | null
     tagAssistedId: string | null
     tagConfirmedId: string | null
     supraEventId: string | null
+    active: boolean | null
     created_at: Date | null
     updated_at: Date | null
   }
@@ -8598,11 +8742,14 @@ export namespace Prisma {
     id: number
     name: number
     date: number
+    startingDate: number
+    endingDate: number
     location: number
     folderId: number
     tagAssistedId: number
     tagConfirmedId: number
     supraEventId: number
+    active: number
     created_at: number
     updated_at: number
     _all: number
@@ -8613,11 +8760,14 @@ export namespace Prisma {
     id?: true
     name?: true
     date?: true
+    startingDate?: true
+    endingDate?: true
     location?: true
     folderId?: true
     tagAssistedId?: true
     tagConfirmedId?: true
     supraEventId?: true
+    active?: true
     created_at?: true
     updated_at?: true
   }
@@ -8626,11 +8776,14 @@ export namespace Prisma {
     id?: true
     name?: true
     date?: true
+    startingDate?: true
+    endingDate?: true
     location?: true
     folderId?: true
     tagAssistedId?: true
     tagConfirmedId?: true
     supraEventId?: true
+    active?: true
     created_at?: true
     updated_at?: true
   }
@@ -8639,11 +8792,14 @@ export namespace Prisma {
     id?: true
     name?: true
     date?: true
+    startingDate?: true
+    endingDate?: true
     location?: true
     folderId?: true
     tagAssistedId?: true
     tagConfirmedId?: true
     supraEventId?: true
+    active?: true
     created_at?: true
     updated_at?: true
     _all?: true
@@ -8725,11 +8881,14 @@ export namespace Prisma {
     id: string
     name: string
     date: Date
+    startingDate: Date
+    endingDate: Date
     location: string
     folderId: string | null
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId: string | null
+    active: boolean
     created_at: Date
     updated_at: Date
     _count: EventCountAggregateOutputType | null
@@ -8755,19 +8914,24 @@ export namespace Prisma {
     id?: boolean
     name?: boolean
     date?: boolean
+    startingDate?: boolean
+    endingDate?: boolean
     location?: boolean
     folderId?: boolean
     tagAssistedId?: boolean
     tagConfirmedId?: boolean
     supraEventId?: boolean
+    active?: boolean
     created_at?: boolean
     updated_at?: boolean
     folder?: boolean | Event$folderArgs<ExtArgs>
     tagAssisted?: boolean | TagDefaultArgs<ExtArgs>
     tagConfirmed?: boolean | TagDefaultArgs<ExtArgs>
     supraEvent?: boolean | Event$supraEventArgs<ExtArgs>
-    subEvents?: boolean | Event$subEventsArgs<ExtArgs>
     tickets?: boolean | Event$ticketsArgs<ExtArgs>
+    subEvents?: boolean | Event$subEventsArgs<ExtArgs>
+    tags?: boolean | Event$tagsArgs<ExtArgs>
+    eventTickets?: boolean | Event$eventTicketsArgs<ExtArgs>
     _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["event"]>
 
@@ -8775,11 +8939,14 @@ export namespace Prisma {
     id?: boolean
     name?: boolean
     date?: boolean
+    startingDate?: boolean
+    endingDate?: boolean
     location?: boolean
     folderId?: boolean
     tagAssistedId?: boolean
     tagConfirmedId?: boolean
     supraEventId?: boolean
+    active?: boolean
     created_at?: boolean
     updated_at?: boolean
     folder?: boolean | Event$folderArgs<ExtArgs>
@@ -8792,11 +8959,14 @@ export namespace Prisma {
     id?: boolean
     name?: boolean
     date?: boolean
+    startingDate?: boolean
+    endingDate?: boolean
     location?: boolean
     folderId?: boolean
     tagAssistedId?: boolean
     tagConfirmedId?: boolean
     supraEventId?: boolean
+    active?: boolean
     created_at?: boolean
     updated_at?: boolean
   }
@@ -8806,8 +8976,10 @@ export namespace Prisma {
     tagAssisted?: boolean | TagDefaultArgs<ExtArgs>
     tagConfirmed?: boolean | TagDefaultArgs<ExtArgs>
     supraEvent?: boolean | Event$supraEventArgs<ExtArgs>
-    subEvents?: boolean | Event$subEventsArgs<ExtArgs>
     tickets?: boolean | Event$ticketsArgs<ExtArgs>
+    subEvents?: boolean | Event$subEventsArgs<ExtArgs>
+    tags?: boolean | Event$tagsArgs<ExtArgs>
+    eventTickets?: boolean | Event$eventTicketsArgs<ExtArgs>
     _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
   }
   export type EventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
@@ -8824,18 +8996,23 @@ export namespace Prisma {
       tagAssisted: Prisma.$TagPayload<ExtArgs>
       tagConfirmed: Prisma.$TagPayload<ExtArgs>
       supraEvent: Prisma.$EventPayload<ExtArgs> | null
-      subEvents: Prisma.$EventPayload<ExtArgs>[]
       tickets: Prisma.$TicketPayload<ExtArgs>[]
+      subEvents: Prisma.$EventPayload<ExtArgs>[]
+      tags: Prisma.$TagPayload<ExtArgs>[]
+      eventTickets: Prisma.$EventTicketPayload<ExtArgs>[]
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
       name: string
       date: Date
+      startingDate: Date
+      endingDate: Date
       location: string
       folderId: string | null
       tagAssistedId: string
       tagConfirmedId: string
       supraEventId: string | null
+      active: boolean
       created_at: Date
       updated_at: Date
     }, ExtArgs["result"]["event"]>
@@ -9206,8 +9383,10 @@ export namespace Prisma {
     tagAssisted<T extends TagDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TagDefaultArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
     tagConfirmed<T extends TagDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TagDefaultArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
     supraEvent<T extends Event$supraEventArgs<ExtArgs> = {}>(args?: Subset<T, Event$supraEventArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
-    subEvents<T extends Event$subEventsArgs<ExtArgs> = {}>(args?: Subset<T, Event$subEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findMany"> | Null>
     tickets<T extends Event$ticketsArgs<ExtArgs> = {}>(args?: Subset<T, Event$ticketsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findMany"> | Null>
+    subEvents<T extends Event$subEventsArgs<ExtArgs> = {}>(args?: Subset<T, Event$subEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findMany"> | Null>
+    tags<T extends Event$tagsArgs<ExtArgs> = {}>(args?: Subset<T, Event$tagsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findMany"> | Null>
+    eventTickets<T extends Event$eventTicketsArgs<ExtArgs> = {}>(args?: Subset<T, Event$eventTicketsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventTicketPayload<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.
@@ -9240,11 +9419,14 @@ export namespace Prisma {
     readonly id: FieldRef<"Event", 'String'>
     readonly name: FieldRef<"Event", 'String'>
     readonly date: FieldRef<"Event", 'DateTime'>
+    readonly startingDate: FieldRef<"Event", 'DateTime'>
+    readonly endingDate: FieldRef<"Event", 'DateTime'>
     readonly location: FieldRef<"Event", 'String'>
     readonly folderId: FieldRef<"Event", 'String'>
     readonly tagAssistedId: FieldRef<"Event", 'String'>
     readonly tagConfirmedId: FieldRef<"Event", 'String'>
     readonly supraEventId: FieldRef<"Event", 'String'>
+    readonly active: FieldRef<"Event", 'Boolean'>
     readonly created_at: FieldRef<"Event", 'DateTime'>
     readonly updated_at: FieldRef<"Event", 'DateTime'>
   }
@@ -9594,6 +9776,26 @@ export namespace Prisma {
     where?: EventWhereInput
   }
 
+  /**
+   * Event.tickets
+   */
+  export type Event$ticketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Ticket
+     */
+    select?: TicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: TicketInclude<ExtArgs> | null
+    where?: TicketWhereInput
+    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
+    cursor?: TicketWhereUniqueInput
+    take?: number
+    skip?: number
+    distinct?: TicketScalarFieldEnum | TicketScalarFieldEnum[]
+  }
+
   /**
    * Event.subEvents
    */
@@ -9615,23 +9817,43 @@ export namespace Prisma {
   }
 
   /**
-   * Event.tickets
+   * Event.tags
    */
-  export type Event$ticketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type Event$tagsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the Ticket
+     * Select specific fields to fetch from the Tag
      */
-    select?: TicketSelect<ExtArgs> | null
+    select?: TagSelect<ExtArgs> | null
     /**
      * Choose, which related nodes to fetch as well
      */
-    include?: TicketInclude<ExtArgs> | null
-    where?: TicketWhereInput
-    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
-    cursor?: TicketWhereUniqueInput
+    include?: TagInclude<ExtArgs> | null
+    where?: TagWhereInput
+    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
+    cursor?: TagWhereUniqueInput
     take?: number
     skip?: number
-    distinct?: TicketScalarFieldEnum | TicketScalarFieldEnum[]
+    distinct?: TagScalarFieldEnum | TagScalarFieldEnum[]
+  }
+
+  /**
+   * Event.eventTickets
+   */
+  export type Event$eventTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    where?: EventTicketWhereInput
+    orderBy?: EventTicketOrderByWithRelationInput | EventTicketOrderByWithRelationInput[]
+    cursor?: EventTicketWhereUniqueInput
+    take?: number
+    skip?: number
+    distinct?: EventTicketScalarFieldEnum | EventTicketScalarFieldEnum[]
   }
 
   /**
@@ -14252,86 +14474,1081 @@ export namespace Prisma {
 
 
   /**
-   * Enums
+   * Model EventTicket
    */
 
-  export const TransactionIsolationLevel: {
-    ReadUncommitted: 'ReadUncommitted',
-    ReadCommitted: 'ReadCommitted',
-    RepeatableRead: 'RepeatableRead',
-    Serializable: 'Serializable'
-  };
-
-  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+  export type AggregateEventTicket = {
+    _count: EventTicketCountAggregateOutputType | null
+    _avg: EventTicketAvgAggregateOutputType | null
+    _sum: EventTicketSumAggregateOutputType | null
+    _min: EventTicketMinAggregateOutputType | null
+    _max: EventTicketMaxAggregateOutputType | null
+  }
 
+  export type EventTicketAvgAggregateOutputType = {
+    amount: number | null
+    price: number | null
+  }
 
-  export const AccountScalarFieldEnum: {
-    id: 'id',
-    username: 'username',
-    password: 'password',
-    role: 'role',
-    isGlobalFilterActive: 'isGlobalFilterActive',
-    fcmToken: 'fcmToken',
-    created_at: 'created_at',
-    updated_at: 'updated_at'
-  };
+  export type EventTicketSumAggregateOutputType = {
+    amount: number | null
+    price: number | null
+  }
 
-  export type AccountScalarFieldEnum = (typeof AccountScalarFieldEnum)[keyof typeof AccountScalarFieldEnum]
+  export type EventTicketMinAggregateOutputType = {
+    id: string | null
+    eventId: string | null
+    amount: number | null
+    type: $Enums.TicketType | null
+    price: number | null
+    created_at: Date | null
+    updated_at: Date | null
+  }
 
+  export type EventTicketMaxAggregateOutputType = {
+    id: string | null
+    eventId: string | null
+    amount: number | null
+    type: $Enums.TicketType | null
+    price: number | null
+    created_at: Date | null
+    updated_at: Date | null
+  }
 
-  export const ProfileScalarFieldEnum: {
-    id: 'id',
-    shortId: 'shortId',
-    phoneNumber: 'phoneNumber',
-    secondaryPhoneNumber: 'secondaryPhoneNumber',
-    fullName: 'fullName',
-    firstName: 'firstName',
-    gender: 'gender',
-    birthDate: 'birthDate',
-    profilePictureUrl: 'profilePictureUrl',
-    instagram: 'instagram',
-    mail: 'mail',
-    dni: 'dni',
-    alternativeNames: 'alternativeNames',
-    birthLocationId: 'birthLocationId',
-    residenceLocationId: 'residenceLocationId',
-    isInTrash: 'isInTrash',
-    movedToTrashDate: 'movedToTrashDate',
-    created_at: 'created_at',
-    updated_at: 'updated_at'
-  };
+  export type EventTicketCountAggregateOutputType = {
+    id: number
+    eventId: number
+    amount: number
+    type: number
+    price: number
+    created_at: number
+    updated_at: number
+    _all: number
+  }
 
-  export type ProfileScalarFieldEnum = (typeof ProfileScalarFieldEnum)[keyof typeof ProfileScalarFieldEnum]
 
+  export type EventTicketAvgAggregateInputType = {
+    amount?: true
+    price?: true
+  }
 
-  export const LocationScalarFieldEnum: {
-    id: 'id',
-    latitude: 'latitude',
-    longitude: 'longitude',
-    country: 'country',
-    state: 'state',
-    city: 'city',
-    created_at: 'created_at',
-    updated_at: 'updated_at'
-  };
+  export type EventTicketSumAggregateInputType = {
+    amount?: true
+    price?: true
+  }
 
-  export type LocationScalarFieldEnum = (typeof LocationScalarFieldEnum)[keyof typeof LocationScalarFieldEnum]
+  export type EventTicketMinAggregateInputType = {
+    id?: true
+    eventId?: true
+    amount?: true
+    type?: true
+    price?: true
+    created_at?: true
+    updated_at?: true
+  }
 
+  export type EventTicketMaxAggregateInputType = {
+    id?: true
+    eventId?: true
+    amount?: true
+    type?: true
+    price?: true
+    created_at?: true
+    updated_at?: true
+  }
 
-  export const CommentScalarFieldEnum: {
-    id: 'id',
-    content: 'content',
-    createdBy: 'createdBy',
-    profileId: 'profileId',
-    isSolvable: 'isSolvable',
-    isSolved: 'isSolved',
-    solvedAt: 'solvedAt',
-    solvedById: 'solvedById',
-    created_at: 'created_at',
-    updated_at: 'updated_at'
-  };
+  export type EventTicketCountAggregateInputType = {
+    id?: true
+    eventId?: true
+    amount?: true
+    type?: true
+    price?: true
+    created_at?: true
+    updated_at?: true
+    _all?: true
+  }
+
+  export type EventTicketAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which EventTicket to aggregate.
+     */
+    where?: EventTicketWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of EventTickets to fetch.
+     */
+    orderBy?: EventTicketOrderByWithRelationInput | EventTicketOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: EventTicketWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` EventTickets 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` EventTickets.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned EventTickets
+    **/
+    _count?: true | EventTicketCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to average
+    **/
+    _avg?: EventTicketAvgAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to sum
+    **/
+    _sum?: EventTicketSumAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: EventTicketMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: EventTicketMaxAggregateInputType
+  }
+
+  export type GetEventTicketAggregateType<T extends EventTicketAggregateArgs> = {
+        [P in keyof T & keyof AggregateEventTicket]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateEventTicket[P]>
+      : GetScalarType<T[P], AggregateEventTicket[P]>
+  }
+
+
+
+
+  export type EventTicketGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: EventTicketWhereInput
+    orderBy?: EventTicketOrderByWithAggregationInput | EventTicketOrderByWithAggregationInput[]
+    by: EventTicketScalarFieldEnum[] | EventTicketScalarFieldEnum
+    having?: EventTicketScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: EventTicketCountAggregateInputType | true
+    _avg?: EventTicketAvgAggregateInputType
+    _sum?: EventTicketSumAggregateInputType
+    _min?: EventTicketMinAggregateInputType
+    _max?: EventTicketMaxAggregateInputType
+  }
+
+  export type EventTicketGroupByOutputType = {
+    id: string
+    eventId: string
+    amount: number
+    type: $Enums.TicketType
+    price: number | null
+    created_at: Date
+    updated_at: Date
+    _count: EventTicketCountAggregateOutputType | null
+    _avg: EventTicketAvgAggregateOutputType | null
+    _sum: EventTicketSumAggregateOutputType | null
+    _min: EventTicketMinAggregateOutputType | null
+    _max: EventTicketMaxAggregateOutputType | null
+  }
+
+  type GetEventTicketGroupByPayload<T extends EventTicketGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<EventTicketGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof EventTicketGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], EventTicketGroupByOutputType[P]>
+            : GetScalarType<T[P], EventTicketGroupByOutputType[P]>
+        }
+      >
+    >
+
+
+  export type EventTicketSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    eventId?: boolean
+    amount?: boolean
+    type?: boolean
+    price?: boolean
+    created_at?: boolean
+    updated_at?: boolean
+    event?: boolean | EventDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["eventTicket"]>
+
+  export type EventTicketSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    eventId?: boolean
+    amount?: boolean
+    type?: boolean
+    price?: boolean
+    created_at?: boolean
+    updated_at?: boolean
+    event?: boolean | EventDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["eventTicket"]>
+
+  export type EventTicketSelectScalar = {
+    id?: boolean
+    eventId?: boolean
+    amount?: boolean
+    type?: boolean
+    price?: boolean
+    created_at?: boolean
+    updated_at?: boolean
+  }
+
+  export type EventTicketInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    event?: boolean | EventDefaultArgs<ExtArgs>
+  }
+  export type EventTicketIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    event?: boolean | EventDefaultArgs<ExtArgs>
+  }
+
+  export type $EventTicketPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "EventTicket"
+    objects: {
+      event: Prisma.$EventPayload<ExtArgs>
+    }
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      eventId: string
+      amount: number
+      type: $Enums.TicketType
+      price: number | null
+      created_at: Date
+      updated_at: Date
+    }, ExtArgs["result"]["eventTicket"]>
+    composites: {}
+  }
+
+  type EventTicketGetPayload<S extends boolean | null | undefined | EventTicketDefaultArgs> = $Result.GetResult<Prisma.$EventTicketPayload, S>
+
+  type EventTicketCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
+    Omit<EventTicketFindManyArgs, 'select' | 'include' | 'distinct'> & {
+      select?: EventTicketCountAggregateInputType | true
+    }
+
+  export interface EventTicketDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['EventTicket'], meta: { name: 'EventTicket' } }
+    /**
+     * Find zero or one EventTicket that matches the filter.
+     * @param {EventTicketFindUniqueArgs} args - Arguments to find a EventTicket
+     * @example
+     * // Get one EventTicket
+     * const eventTicket = await prisma.eventTicket.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends EventTicketFindUniqueArgs>(args: SelectSubset<T, EventTicketFindUniqueArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
+
+    /**
+     * Find one EventTicket that matches the filter or throw an error with `error.code='P2025'` 
+     * if no matches were found.
+     * @param {EventTicketFindUniqueOrThrowArgs} args - Arguments to find a EventTicket
+     * @example
+     * // Get one EventTicket
+     * const eventTicket = await prisma.eventTicket.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends EventTicketFindUniqueOrThrowArgs>(args: SelectSubset<T, EventTicketFindUniqueOrThrowArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
+
+    /**
+     * Find the first EventTicket 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 {EventTicketFindFirstArgs} args - Arguments to find a EventTicket
+     * @example
+     * // Get one EventTicket
+     * const eventTicket = await prisma.eventTicket.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends EventTicketFindFirstArgs>(args?: SelectSubset<T, EventTicketFindFirstArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
+
+    /**
+     * Find the first EventTicket 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 {EventTicketFindFirstOrThrowArgs} args - Arguments to find a EventTicket
+     * @example
+     * // Get one EventTicket
+     * const eventTicket = await prisma.eventTicket.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends EventTicketFindFirstOrThrowArgs>(args?: SelectSubset<T, EventTicketFindFirstOrThrowArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
+
+    /**
+     * Find zero or more EventTickets 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 {EventTicketFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all EventTickets
+     * const eventTickets = await prisma.eventTicket.findMany()
+     * 
+     * // Get first 10 EventTickets
+     * const eventTickets = await prisma.eventTicket.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const eventTicketWithIdOnly = await prisma.eventTicket.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends EventTicketFindManyArgs>(args?: SelectSubset<T, EventTicketFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "findMany">>
+
+    /**
+     * Create a EventTicket.
+     * @param {EventTicketCreateArgs} args - Arguments to create a EventTicket.
+     * @example
+     * // Create one EventTicket
+     * const EventTicket = await prisma.eventTicket.create({
+     *   data: {
+     *     // ... data to create a EventTicket
+     *   }
+     * })
+     * 
+     */
+    create<T extends EventTicketCreateArgs>(args: SelectSubset<T, EventTicketCreateArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "create">, never, ExtArgs>
+
+    /**
+     * Create many EventTickets.
+     * @param {EventTicketCreateManyArgs} args - Arguments to create many EventTickets.
+     * @example
+     * // Create many EventTickets
+     * const eventTicket = await prisma.eventTicket.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends EventTicketCreateManyArgs>(args?: SelectSubset<T, EventTicketCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many EventTickets and returns the data saved in the database.
+     * @param {EventTicketCreateManyAndReturnArgs} args - Arguments to create many EventTickets.
+     * @example
+     * // Create many EventTickets
+     * const eventTicket = await prisma.eventTicket.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many EventTickets and only return the `id`
+     * const eventTicketWithIdOnly = await prisma.eventTicket.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 EventTicketCreateManyAndReturnArgs>(args?: SelectSubset<T, EventTicketCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "createManyAndReturn">>
+
+    /**
+     * Delete a EventTicket.
+     * @param {EventTicketDeleteArgs} args - Arguments to delete one EventTicket.
+     * @example
+     * // Delete one EventTicket
+     * const EventTicket = await prisma.eventTicket.delete({
+     *   where: {
+     *     // ... filter to delete one EventTicket
+     *   }
+     * })
+     * 
+     */
+    delete<T extends EventTicketDeleteArgs>(args: SelectSubset<T, EventTicketDeleteArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "delete">, never, ExtArgs>
+
+    /**
+     * Update one EventTicket.
+     * @param {EventTicketUpdateArgs} args - Arguments to update one EventTicket.
+     * @example
+     * // Update one EventTicket
+     * const eventTicket = await prisma.eventTicket.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends EventTicketUpdateArgs>(args: SelectSubset<T, EventTicketUpdateArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "update">, never, ExtArgs>
+
+    /**
+     * Delete zero or more EventTickets.
+     * @param {EventTicketDeleteManyArgs} args - Arguments to filter EventTickets to delete.
+     * @example
+     * // Delete a few EventTickets
+     * const { count } = await prisma.eventTicket.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends EventTicketDeleteManyArgs>(args?: SelectSubset<T, EventTicketDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more EventTickets.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {EventTicketUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many EventTickets
+     * const eventTicket = await prisma.eventTicket.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends EventTicketUpdateManyArgs>(args: SelectSubset<T, EventTicketUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create or update one EventTicket.
+     * @param {EventTicketUpsertArgs} args - Arguments to update or create a EventTicket.
+     * @example
+     * // Update or create a EventTicket
+     * const eventTicket = await prisma.eventTicket.upsert({
+     *   create: {
+     *     // ... data to create a EventTicket
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the EventTicket we want to update
+     *   }
+     * })
+     */
+    upsert<T extends EventTicketUpsertArgs>(args: SelectSubset<T, EventTicketUpsertArgs<ExtArgs>>): Prisma__EventTicketClient<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
+
+
+    /**
+     * Count the number of EventTickets.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {EventTicketCountArgs} args - Arguments to filter EventTickets to count.
+     * @example
+     * // Count the number of EventTickets
+     * const count = await prisma.eventTicket.count({
+     *   where: {
+     *     // ... the filter for the EventTickets we want to count
+     *   }
+     * })
+    **/
+    count<T extends EventTicketCountArgs>(
+      args?: Subset<T, EventTicketCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], EventTicketCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a EventTicket.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {EventTicketAggregateArgs} 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 EventTicketAggregateArgs>(args: Subset<T, EventTicketAggregateArgs>): Prisma.PrismaPromise<GetEventTicketAggregateType<T>>
+
+    /**
+     * Group by EventTicket.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {EventTicketGroupByArgs} 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 EventTicketGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: EventTicketGroupByArgs['orderBy'] }
+        : { orderBy?: EventTicketGroupByArgs['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, EventTicketGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetEventTicketGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the EventTicket model
+   */
+  readonly fields: EventTicketFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for EventTicket.
+   * 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__EventTicketClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    event<T extends EventDefaultArgs<ExtArgs> = {}>(args?: Subset<T, EventDefaultArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<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.
+     * @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 EventTicket model
+   */ 
+  interface EventTicketFieldRefs {
+    readonly id: FieldRef<"EventTicket", 'String'>
+    readonly eventId: FieldRef<"EventTicket", 'String'>
+    readonly amount: FieldRef<"EventTicket", 'Int'>
+    readonly type: FieldRef<"EventTicket", 'TicketType'>
+    readonly price: FieldRef<"EventTicket", 'Float'>
+    readonly created_at: FieldRef<"EventTicket", 'DateTime'>
+    readonly updated_at: FieldRef<"EventTicket", 'DateTime'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * EventTicket findUnique
+   */
+  export type EventTicketFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * Filter, which EventTicket to fetch.
+     */
+    where: EventTicketWhereUniqueInput
+  }
+
+  /**
+   * EventTicket findUniqueOrThrow
+   */
+  export type EventTicketFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * Filter, which EventTicket to fetch.
+     */
+    where: EventTicketWhereUniqueInput
+  }
+
+  /**
+   * EventTicket findFirst
+   */
+  export type EventTicketFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * Filter, which EventTicket to fetch.
+     */
+    where?: EventTicketWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of EventTickets to fetch.
+     */
+    orderBy?: EventTicketOrderByWithRelationInput | EventTicketOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for EventTickets.
+     */
+    cursor?: EventTicketWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` EventTickets 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` EventTickets.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of EventTickets.
+     */
+    distinct?: EventTicketScalarFieldEnum | EventTicketScalarFieldEnum[]
+  }
+
+  /**
+   * EventTicket findFirstOrThrow
+   */
+  export type EventTicketFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * Filter, which EventTicket to fetch.
+     */
+    where?: EventTicketWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of EventTickets to fetch.
+     */
+    orderBy?: EventTicketOrderByWithRelationInput | EventTicketOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for EventTickets.
+     */
+    cursor?: EventTicketWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` EventTickets 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` EventTickets.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of EventTickets.
+     */
+    distinct?: EventTicketScalarFieldEnum | EventTicketScalarFieldEnum[]
+  }
+
+  /**
+   * EventTicket findMany
+   */
+  export type EventTicketFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * Filter, which EventTickets to fetch.
+     */
+    where?: EventTicketWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of EventTickets to fetch.
+     */
+    orderBy?: EventTicketOrderByWithRelationInput | EventTicketOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing EventTickets.
+     */
+    cursor?: EventTicketWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` EventTickets 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` EventTickets.
+     */
+    skip?: number
+    distinct?: EventTicketScalarFieldEnum | EventTicketScalarFieldEnum[]
+  }
+
+  /**
+   * EventTicket create
+   */
+  export type EventTicketCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * The data needed to create a EventTicket.
+     */
+    data: XOR<EventTicketCreateInput, EventTicketUncheckedCreateInput>
+  }
+
+  /**
+   * EventTicket createMany
+   */
+  export type EventTicketCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many EventTickets.
+     */
+    data: EventTicketCreateManyInput | EventTicketCreateManyInput[]
+    skipDuplicates?: boolean
+  }
+
+  /**
+   * EventTicket createManyAndReturn
+   */
+  export type EventTicketCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelectCreateManyAndReturn<ExtArgs> | null
+    /**
+     * The data used to create many EventTickets.
+     */
+    data: EventTicketCreateManyInput | EventTicketCreateManyInput[]
+    skipDuplicates?: boolean
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketIncludeCreateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * EventTicket update
+   */
+  export type EventTicketUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * The data needed to update a EventTicket.
+     */
+    data: XOR<EventTicketUpdateInput, EventTicketUncheckedUpdateInput>
+    /**
+     * Choose, which EventTicket to update.
+     */
+    where: EventTicketWhereUniqueInput
+  }
+
+  /**
+   * EventTicket updateMany
+   */
+  export type EventTicketUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update EventTickets.
+     */
+    data: XOR<EventTicketUpdateManyMutationInput, EventTicketUncheckedUpdateManyInput>
+    /**
+     * Filter which EventTickets to update
+     */
+    where?: EventTicketWhereInput
+  }
+
+  /**
+   * EventTicket upsert
+   */
+  export type EventTicketUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * The filter to search for the EventTicket to update in case it exists.
+     */
+    where: EventTicketWhereUniqueInput
+    /**
+     * In case the EventTicket found by the `where` argument doesn't exist, create a new EventTicket with this data.
+     */
+    create: XOR<EventTicketCreateInput, EventTicketUncheckedCreateInput>
+    /**
+     * In case the EventTicket was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<EventTicketUpdateInput, EventTicketUncheckedUpdateInput>
+  }
+
+  /**
+   * EventTicket delete
+   */
+  export type EventTicketDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+    /**
+     * Filter which EventTicket to delete.
+     */
+    where: EventTicketWhereUniqueInput
+  }
+
+  /**
+   * EventTicket deleteMany
+   */
+  export type EventTicketDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which EventTickets to delete
+     */
+    where?: EventTicketWhereInput
+  }
+
+  /**
+   * EventTicket without action
+   */
+  export type EventTicketDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the EventTicket
+     */
+    select?: EventTicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: EventTicketInclude<ExtArgs> | null
+  }
+
+
+  /**
+   * Enums
+   */
+
+  export const TransactionIsolationLevel: {
+    ReadUncommitted: 'ReadUncommitted',
+    ReadCommitted: 'ReadCommitted',
+    RepeatableRead: 'RepeatableRead',
+    Serializable: 'Serializable'
+  };
+
+  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+  export const AccountScalarFieldEnum: {
+    id: 'id',
+    username: 'username',
+    password: 'password',
+    role: 'role',
+    isGlobalFilterActive: 'isGlobalFilterActive',
+    fcmToken: 'fcmToken',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+  };
+
+  export type AccountScalarFieldEnum = (typeof AccountScalarFieldEnum)[keyof typeof AccountScalarFieldEnum]
 
-  export type CommentScalarFieldEnum = (typeof CommentScalarFieldEnum)[keyof typeof CommentScalarFieldEnum]
+
+  export const ProfileScalarFieldEnum: {
+    id: 'id',
+    shortId: 'shortId',
+    phoneNumber: 'phoneNumber',
+    secondaryPhoneNumber: 'secondaryPhoneNumber',
+    fullName: 'fullName',
+    firstName: 'firstName',
+    gender: 'gender',
+    birthDate: 'birthDate',
+    profilePictureUrl: 'profilePictureUrl',
+    instagram: 'instagram',
+    mail: 'mail',
+    dni: 'dni',
+    alternativeNames: 'alternativeNames',
+    birthLocationId: 'birthLocationId',
+    residenceLocationId: 'residenceLocationId',
+    isInTrash: 'isInTrash',
+    movedToTrashDate: 'movedToTrashDate',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+  };
+
+  export type ProfileScalarFieldEnum = (typeof ProfileScalarFieldEnum)[keyof typeof ProfileScalarFieldEnum]
+
+
+  export const LocationScalarFieldEnum: {
+    id: 'id',
+    latitude: 'latitude',
+    longitude: 'longitude',
+    country: 'country',
+    state: 'state',
+    city: 'city',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+  };
+
+  export type LocationScalarFieldEnum = (typeof LocationScalarFieldEnum)[keyof typeof LocationScalarFieldEnum]
+
+
+  export const CommentScalarFieldEnum: {
+    id: 'id',
+    content: 'content',
+    createdBy: 'createdBy',
+    profileId: 'profileId',
+    isSolvable: 'isSolvable',
+    isSolved: 'isSolved',
+    solvedAt: 'solvedAt',
+    solvedById: 'solvedById',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+  };
+
+  export type CommentScalarFieldEnum = (typeof CommentScalarFieldEnum)[keyof typeof CommentScalarFieldEnum]
 
 
   export const TagScalarFieldEnum: {
@@ -14362,11 +15579,14 @@ export namespace Prisma {
     id: 'id',
     name: 'name',
     date: 'date',
+    startingDate: 'startingDate',
+    endingDate: 'endingDate',
     location: 'location',
     folderId: 'folderId',
     tagAssistedId: 'tagAssistedId',
     tagConfirmedId: 'tagConfirmedId',
     supraEventId: 'supraEventId',
+    active: 'active',
     created_at: 'created_at',
     updated_at: 'updated_at'
   };
@@ -14432,6 +15652,19 @@ export namespace Prisma {
   export type EnumsScalarFieldEnum = (typeof EnumsScalarFieldEnum)[keyof typeof EnumsScalarFieldEnum]
 
 
+  export const EventTicketScalarFieldEnum: {
+    id: 'id',
+    eventId: 'eventId',
+    amount: 'amount',
+    type: 'type',
+    price: 'price',
+    created_at: 'created_at',
+    updated_at: 'updated_at'
+  };
+
+  export type EventTicketScalarFieldEnum = (typeof EventTicketScalarFieldEnum)[keyof typeof EventTicketScalarFieldEnum]
+
+
   export const SortOrder: {
     asc: 'asc',
     desc: 'desc'
@@ -15044,6 +16277,7 @@ export namespace Prisma {
     accounts?: AccountListRelationFilter
     profiles?: ProfileListRelationFilter
     accountsGlobalFilter?: AccountListRelationFilter
+    Event?: EventListRelationFilter
   }
 
   export type TagOrderByWithRelationInput = {
@@ -15059,6 +16293,7 @@ export namespace Prisma {
     accounts?: AccountOrderByRelationAggregateInput
     profiles?: ProfileOrderByRelationAggregateInput
     accountsGlobalFilter?: AccountOrderByRelationAggregateInput
+    Event?: EventOrderByRelationAggregateInput
   }
 
   export type TagWhereUniqueInput = Prisma.AtLeast<{
@@ -15077,6 +16312,7 @@ export namespace Prisma {
     accounts?: AccountListRelationFilter
     profiles?: ProfileListRelationFilter
     accountsGlobalFilter?: AccountListRelationFilter
+    Event?: EventListRelationFilter
   }, "id">
 
   export type TagOrderByWithAggregationInput = {
@@ -15170,38 +16406,48 @@ export namespace Prisma {
     id?: StringFilter<"Event"> | string
     name?: StringFilter<"Event"> | string
     date?: DateTimeFilter<"Event"> | Date | string
+    startingDate?: DateTimeFilter<"Event"> | Date | string
+    endingDate?: DateTimeFilter<"Event"> | Date | string
     location?: StringFilter<"Event"> | string
     folderId?: StringNullableFilter<"Event"> | string | null
     tagAssistedId?: StringFilter<"Event"> | string
     tagConfirmedId?: StringFilter<"Event"> | string
     supraEventId?: StringNullableFilter<"Event"> | string | null
+    active?: BoolFilter<"Event"> | boolean
     created_at?: DateTimeFilter<"Event"> | Date | string
     updated_at?: DateTimeFilter<"Event"> | Date | string
     folder?: XOR<EventFolderNullableRelationFilter, EventFolderWhereInput> | null
     tagAssisted?: XOR<TagRelationFilter, TagWhereInput>
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
-    subEvents?: EventListRelationFilter
     tickets?: TicketListRelationFilter
+    subEvents?: EventListRelationFilter
+    tags?: TagListRelationFilter
+    eventTickets?: EventTicketListRelationFilter
   }
 
   export type EventOrderByWithRelationInput = {
     id?: SortOrder
     name?: SortOrder
     date?: SortOrder
+    startingDate?: SortOrder
+    endingDate?: SortOrder
     location?: SortOrder
     folderId?: SortOrderInput | SortOrder
     tagAssistedId?: SortOrder
     tagConfirmedId?: SortOrder
     supraEventId?: SortOrderInput | SortOrder
+    active?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
     folder?: EventFolderOrderByWithRelationInput
     tagAssisted?: TagOrderByWithRelationInput
     tagConfirmed?: TagOrderByWithRelationInput
     supraEvent?: EventOrderByWithRelationInput
-    subEvents?: EventOrderByRelationAggregateInput
     tickets?: TicketOrderByRelationAggregateInput
+    subEvents?: EventOrderByRelationAggregateInput
+    tags?: TagOrderByRelationAggregateInput
+    eventTickets?: EventTicketOrderByRelationAggregateInput
   }
 
   export type EventWhereUniqueInput = Prisma.AtLeast<{
@@ -15213,28 +16459,36 @@ export namespace Prisma {
     NOT?: EventWhereInput | EventWhereInput[]
     name?: StringFilter<"Event"> | string
     date?: DateTimeFilter<"Event"> | Date | string
+    startingDate?: DateTimeFilter<"Event"> | Date | string
+    endingDate?: DateTimeFilter<"Event"> | Date | string
     location?: StringFilter<"Event"> | string
     folderId?: StringNullableFilter<"Event"> | string | null
     supraEventId?: StringNullableFilter<"Event"> | string | null
+    active?: BoolFilter<"Event"> | boolean
     created_at?: DateTimeFilter<"Event"> | Date | string
     updated_at?: DateTimeFilter<"Event"> | Date | string
     folder?: XOR<EventFolderNullableRelationFilter, EventFolderWhereInput> | null
     tagAssisted?: XOR<TagRelationFilter, TagWhereInput>
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
-    subEvents?: EventListRelationFilter
     tickets?: TicketListRelationFilter
+    subEvents?: EventListRelationFilter
+    tags?: TagListRelationFilter
+    eventTickets?: EventTicketListRelationFilter
   }, "id" | "tagAssistedId" | "tagConfirmedId">
 
   export type EventOrderByWithAggregationInput = {
     id?: SortOrder
     name?: SortOrder
     date?: SortOrder
+    startingDate?: SortOrder
+    endingDate?: SortOrder
     location?: SortOrder
     folderId?: SortOrderInput | SortOrder
     tagAssistedId?: SortOrder
     tagConfirmedId?: SortOrder
     supraEventId?: SortOrderInput | SortOrder
+    active?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
     _count?: EventCountOrderByAggregateInput
@@ -15249,11 +16503,14 @@ export namespace Prisma {
     id?: StringWithAggregatesFilter<"Event"> | string
     name?: StringWithAggregatesFilter<"Event"> | string
     date?: DateTimeWithAggregatesFilter<"Event"> | Date | string
+    startingDate?: DateTimeWithAggregatesFilter<"Event"> | Date | string
+    endingDate?: DateTimeWithAggregatesFilter<"Event"> | Date | string
     location?: StringWithAggregatesFilter<"Event"> | string
     folderId?: StringNullableWithAggregatesFilter<"Event"> | string | null
     tagAssistedId?: StringWithAggregatesFilter<"Event"> | string
     tagConfirmedId?: StringWithAggregatesFilter<"Event"> | string
     supraEventId?: StringNullableWithAggregatesFilter<"Event"> | string | null
+    active?: BoolWithAggregatesFilter<"Event"> | boolean
     created_at?: DateTimeWithAggregatesFilter<"Event"> | Date | string
     updated_at?: DateTimeWithAggregatesFilter<"Event"> | Date | string
   }
@@ -15542,6 +16799,73 @@ export namespace Prisma {
     templateCategory?: EnumTemplateCategoryWithAggregatesFilter<"Enums"> | $Enums.TemplateCategory
   }
 
+  export type EventTicketWhereInput = {
+    AND?: EventTicketWhereInput | EventTicketWhereInput[]
+    OR?: EventTicketWhereInput[]
+    NOT?: EventTicketWhereInput | EventTicketWhereInput[]
+    id?: StringFilter<"EventTicket"> | string
+    eventId?: StringFilter<"EventTicket"> | string
+    amount?: IntFilter<"EventTicket"> | number
+    type?: EnumTicketTypeFilter<"EventTicket"> | $Enums.TicketType
+    price?: FloatNullableFilter<"EventTicket"> | number | null
+    created_at?: DateTimeFilter<"EventTicket"> | Date | string
+    updated_at?: DateTimeFilter<"EventTicket"> | Date | string
+    event?: XOR<EventRelationFilter, EventWhereInput>
+  }
+
+  export type EventTicketOrderByWithRelationInput = {
+    id?: SortOrder
+    eventId?: SortOrder
+    amount?: SortOrder
+    type?: SortOrder
+    price?: SortOrderInput | SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+    event?: EventOrderByWithRelationInput
+  }
+
+  export type EventTicketWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    AND?: EventTicketWhereInput | EventTicketWhereInput[]
+    OR?: EventTicketWhereInput[]
+    NOT?: EventTicketWhereInput | EventTicketWhereInput[]
+    eventId?: StringFilter<"EventTicket"> | string
+    amount?: IntFilter<"EventTicket"> | number
+    type?: EnumTicketTypeFilter<"EventTicket"> | $Enums.TicketType
+    price?: FloatNullableFilter<"EventTicket"> | number | null
+    created_at?: DateTimeFilter<"EventTicket"> | Date | string
+    updated_at?: DateTimeFilter<"EventTicket"> | Date | string
+    event?: XOR<EventRelationFilter, EventWhereInput>
+  }, "id">
+
+  export type EventTicketOrderByWithAggregationInput = {
+    id?: SortOrder
+    eventId?: SortOrder
+    amount?: SortOrder
+    type?: SortOrder
+    price?: SortOrderInput | SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+    _count?: EventTicketCountOrderByAggregateInput
+    _avg?: EventTicketAvgOrderByAggregateInput
+    _max?: EventTicketMaxOrderByAggregateInput
+    _min?: EventTicketMinOrderByAggregateInput
+    _sum?: EventTicketSumOrderByAggregateInput
+  }
+
+  export type EventTicketScalarWhereWithAggregatesInput = {
+    AND?: EventTicketScalarWhereWithAggregatesInput | EventTicketScalarWhereWithAggregatesInput[]
+    OR?: EventTicketScalarWhereWithAggregatesInput[]
+    NOT?: EventTicketScalarWhereWithAggregatesInput | EventTicketScalarWhereWithAggregatesInput[]
+    id?: StringWithAggregatesFilter<"EventTicket"> | string
+    eventId?: StringWithAggregatesFilter<"EventTicket"> | string
+    amount?: IntWithAggregatesFilter<"EventTicket"> | number
+    type?: EnumTicketTypeWithAggregatesFilter<"EventTicket"> | $Enums.TicketType
+    price?: FloatNullableWithAggregatesFilter<"EventTicket"> | number | null
+    created_at?: DateTimeWithAggregatesFilter<"EventTicket"> | Date | string
+    updated_at?: DateTimeWithAggregatesFilter<"EventTicket"> | Date | string
+  }
+
   export type AccountCreateInput = {
     id?: string
     username: string
@@ -15984,6 +17308,7 @@ export namespace Prisma {
     accounts?: AccountCreateNestedManyWithoutTagsInput
     profiles?: ProfileCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateInput = {
@@ -15998,6 +17323,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
     profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagUpdateInput = {
@@ -16012,6 +17338,7 @@ export namespace Prisma {
     accounts?: AccountUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateInput = {
@@ -16026,6 +17353,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type TagCreateManyInput = {
@@ -16125,71 +17453,94 @@ export namespace Prisma {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
-    subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
-    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventUpdateInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
-    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventCreateManyInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
   }
@@ -16198,7 +17549,10 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -16207,11 +17561,14 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -16519,6 +17876,75 @@ export namespace Prisma {
     templateCategory?: EnumTemplateCategoryFieldUpdateOperationsInput | $Enums.TemplateCategory
   }
 
+  export type EventTicketCreateInput = {
+    id?: string
+    amount: number
+    type: $Enums.TicketType
+    price?: number | null
+    created_at?: Date | string
+    updated_at?: Date | string
+    event: EventCreateNestedOneWithoutEventTicketsInput
+  }
+
+  export type EventTicketUncheckedCreateInput = {
+    id?: string
+    eventId: string
+    amount: number
+    type: $Enums.TicketType
+    price?: number | null
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
+  export type EventTicketUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    event?: EventUpdateOneRequiredWithoutEventTicketsNestedInput
+  }
+
+  export type EventTicketUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    eventId?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type EventTicketCreateManyInput = {
+    id?: string
+    eventId: string
+    amount: number
+    type: $Enums.TicketType
+    price?: number | null
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
+  export type EventTicketUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type EventTicketUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    eventId?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
   export type StringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -17005,10 +18431,20 @@ export namespace Prisma {
     none?: AccountWhereInput
   }
 
+  export type EventListRelationFilter = {
+    every?: EventWhereInput
+    some?: EventWhereInput
+    none?: EventWhereInput
+  }
+
   export type AccountOrderByRelationAggregateInput = {
     _count?: SortOrder
   }
 
+  export type EventOrderByRelationAggregateInput = {
+    _count?: SortOrder
+  }
+
   export type TagCountOrderByAggregateInput = {
     id?: SortOrder
     name?: SortOrder
@@ -17083,35 +18519,38 @@ export namespace Prisma {
     isNot?: TagWhereInput
   }
 
-  export type EventListRelationFilter = {
-    every?: EventWhereInput
-    some?: EventWhereInput
-    none?: EventWhereInput
-  }
-
   export type TicketListRelationFilter = {
     every?: TicketWhereInput
     some?: TicketWhereInput
     none?: TicketWhereInput
   }
 
-  export type EventOrderByRelationAggregateInput = {
-    _count?: SortOrder
+  export type EventTicketListRelationFilter = {
+    every?: EventTicketWhereInput
+    some?: EventTicketWhereInput
+    none?: EventTicketWhereInput
   }
 
   export type TicketOrderByRelationAggregateInput = {
     _count?: SortOrder
   }
 
+  export type EventTicketOrderByRelationAggregateInput = {
+    _count?: SortOrder
+  }
+
   export type EventCountOrderByAggregateInput = {
     id?: SortOrder
     name?: SortOrder
     date?: SortOrder
+    startingDate?: SortOrder
+    endingDate?: SortOrder
     location?: SortOrder
     folderId?: SortOrder
     tagAssistedId?: SortOrder
     tagConfirmedId?: SortOrder
     supraEventId?: SortOrder
+    active?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
@@ -17120,11 +18559,14 @@ export namespace Prisma {
     id?: SortOrder
     name?: SortOrder
     date?: SortOrder
+    startingDate?: SortOrder
+    endingDate?: SortOrder
     location?: SortOrder
     folderId?: SortOrder
     tagAssistedId?: SortOrder
     tagConfirmedId?: SortOrder
     supraEventId?: SortOrder
+    active?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
@@ -17133,11 +18575,14 @@ export namespace Prisma {
     id?: SortOrder
     name?: SortOrder
     date?: SortOrder
+    startingDate?: SortOrder
+    endingDate?: SortOrder
     location?: SortOrder
     folderId?: SortOrder
     tagAssistedId?: SortOrder
     tagConfirmedId?: SortOrder
     supraEventId?: SortOrder
+    active?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
@@ -17406,6 +18851,73 @@ export namespace Prisma {
     _max?: NestedEnumTemplateCategoryFilter<$PrismaModel>
   }
 
+  export type FloatNullableFilter<$PrismaModel = never> = {
+    equals?: number | FloatFieldRefInput<$PrismaModel> | null
+    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    lt?: number | FloatFieldRefInput<$PrismaModel>
+    lte?: number | FloatFieldRefInput<$PrismaModel>
+    gt?: number | FloatFieldRefInput<$PrismaModel>
+    gte?: number | FloatFieldRefInput<$PrismaModel>
+    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
+  }
+
+  export type EventTicketCountOrderByAggregateInput = {
+    id?: SortOrder
+    eventId?: SortOrder
+    amount?: SortOrder
+    type?: SortOrder
+    price?: SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+  }
+
+  export type EventTicketAvgOrderByAggregateInput = {
+    amount?: SortOrder
+    price?: SortOrder
+  }
+
+  export type EventTicketMaxOrderByAggregateInput = {
+    id?: SortOrder
+    eventId?: SortOrder
+    amount?: SortOrder
+    type?: SortOrder
+    price?: SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+  }
+
+  export type EventTicketMinOrderByAggregateInput = {
+    id?: SortOrder
+    eventId?: SortOrder
+    amount?: SortOrder
+    type?: SortOrder
+    price?: SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+  }
+
+  export type EventTicketSumOrderByAggregateInput = {
+    amount?: SortOrder
+    price?: SortOrder
+  }
+
+  export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: number | FloatFieldRefInput<$PrismaModel> | null
+    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    lt?: number | FloatFieldRefInput<$PrismaModel>
+    lte?: number | FloatFieldRefInput<$PrismaModel>
+    gt?: number | FloatFieldRefInput<$PrismaModel>
+    gte?: number | FloatFieldRefInput<$PrismaModel>
+    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
+    _count?: NestedIntNullableFilter<$PrismaModel>
+    _avg?: NestedFloatNullableFilter<$PrismaModel>
+    _sum?: NestedFloatNullableFilter<$PrismaModel>
+    _min?: NestedFloatNullableFilter<$PrismaModel>
+    _max?: NestedFloatNullableFilter<$PrismaModel>
+  }
+
   export type AccountCreatefcmTokenInput = {
     set: string[]
   }
@@ -17942,6 +19454,12 @@ export namespace Prisma {
     connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
   }
 
+  export type EventCreateNestedManyWithoutTagsInput = {
+    create?: XOR<EventCreateWithoutTagsInput, EventUncheckedCreateWithoutTagsInput> | EventCreateWithoutTagsInput[] | EventUncheckedCreateWithoutTagsInput[]
+    connectOrCreate?: EventCreateOrConnectWithoutTagsInput | EventCreateOrConnectWithoutTagsInput[]
+    connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
+  }
+
   export type EventUncheckedCreateNestedOneWithoutTagAssistedInput = {
     create?: XOR<EventCreateWithoutTagAssistedInput, EventUncheckedCreateWithoutTagAssistedInput>
     connectOrCreate?: EventCreateOrConnectWithoutTagAssistedInput
@@ -17972,6 +19490,12 @@ export namespace Prisma {
     connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
   }
 
+  export type EventUncheckedCreateNestedManyWithoutTagsInput = {
+    create?: XOR<EventCreateWithoutTagsInput, EventUncheckedCreateWithoutTagsInput> | EventCreateWithoutTagsInput[] | EventUncheckedCreateWithoutTagsInput[]
+    connectOrCreate?: EventCreateOrConnectWithoutTagsInput | EventCreateOrConnectWithoutTagsInput[]
+    connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
+  }
+
   export type EnumTagTypeFieldUpdateOperationsInput = {
     set?: $Enums.TagType
   }
@@ -18043,6 +19567,19 @@ export namespace Prisma {
     deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
   }
 
+  export type EventUpdateManyWithoutTagsNestedInput = {
+    create?: XOR<EventCreateWithoutTagsInput, EventUncheckedCreateWithoutTagsInput> | EventCreateWithoutTagsInput[] | EventUncheckedCreateWithoutTagsInput[]
+    connectOrCreate?: EventCreateOrConnectWithoutTagsInput | EventCreateOrConnectWithoutTagsInput[]
+    upsert?: EventUpsertWithWhereUniqueWithoutTagsInput | EventUpsertWithWhereUniqueWithoutTagsInput[]
+    set?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    disconnect?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    delete?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    update?: EventUpdateWithWhereUniqueWithoutTagsInput | EventUpdateWithWhereUniqueWithoutTagsInput[]
+    updateMany?: EventUpdateManyWithWhereWithoutTagsInput | EventUpdateManyWithWhereWithoutTagsInput[]
+    deleteMany?: EventScalarWhereInput | EventScalarWhereInput[]
+  }
+
   export type EventUncheckedUpdateOneWithoutTagAssistedNestedInput = {
     create?: XOR<EventCreateWithoutTagAssistedInput, EventUncheckedCreateWithoutTagAssistedInput>
     connectOrCreate?: EventCreateOrConnectWithoutTagAssistedInput
@@ -18102,6 +19639,19 @@ export namespace Prisma {
     deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
   }
 
+  export type EventUncheckedUpdateManyWithoutTagsNestedInput = {
+    create?: XOR<EventCreateWithoutTagsInput, EventUncheckedCreateWithoutTagsInput> | EventCreateWithoutTagsInput[] | EventUncheckedCreateWithoutTagsInput[]
+    connectOrCreate?: EventCreateOrConnectWithoutTagsInput | EventCreateOrConnectWithoutTagsInput[]
+    upsert?: EventUpsertWithWhereUniqueWithoutTagsInput | EventUpsertWithWhereUniqueWithoutTagsInput[]
+    set?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    disconnect?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    delete?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
+    update?: EventUpdateWithWhereUniqueWithoutTagsInput | EventUpdateWithWhereUniqueWithoutTagsInput[]
+    updateMany?: EventUpdateManyWithWhereWithoutTagsInput | EventUpdateManyWithWhereWithoutTagsInput[]
+    deleteMany?: EventScalarWhereInput | EventScalarWhereInput[]
+  }
+
   export type TagCreateNestedManyWithoutGroupInput = {
     create?: XOR<TagCreateWithoutGroupInput, TagUncheckedCreateWithoutGroupInput> | TagCreateWithoutGroupInput[] | TagUncheckedCreateWithoutGroupInput[]
     connectOrCreate?: TagCreateOrConnectWithoutGroupInput | TagCreateOrConnectWithoutGroupInput[]
@@ -18168,6 +19718,13 @@ export namespace Prisma {
     connect?: EventWhereUniqueInput
   }
 
+  export type TicketCreateNestedManyWithoutEventInput = {
+    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
+    createMany?: TicketCreateManyEventInputEnvelope
+    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+  }
+
   export type EventCreateNestedManyWithoutSupraEventInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18175,7 +19732,20 @@ export namespace Prisma {
     connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
   }
 
-  export type TicketCreateNestedManyWithoutEventInput = {
+  export type TagCreateNestedManyWithoutEventInput = {
+    create?: XOR<TagCreateWithoutEventInput, TagUncheckedCreateWithoutEventInput> | TagCreateWithoutEventInput[] | TagUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TagCreateOrConnectWithoutEventInput | TagCreateOrConnectWithoutEventInput[]
+    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
+  }
+
+  export type EventTicketCreateNestedManyWithoutEventInput = {
+    create?: XOR<EventTicketCreateWithoutEventInput, EventTicketUncheckedCreateWithoutEventInput> | EventTicketCreateWithoutEventInput[] | EventTicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: EventTicketCreateOrConnectWithoutEventInput | EventTicketCreateOrConnectWithoutEventInput[]
+    createMany?: EventTicketCreateManyEventInputEnvelope
+    connect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+  }
+
+  export type TicketUncheckedCreateNestedManyWithoutEventInput = {
     create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
     connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
     createMany?: TicketCreateManyEventInputEnvelope
@@ -18189,11 +19759,17 @@ export namespace Prisma {
     connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
   }
 
-  export type TicketUncheckedCreateNestedManyWithoutEventInput = {
-    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
-    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
-    createMany?: TicketCreateManyEventInputEnvelope
-    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+  export type TagUncheckedCreateNestedManyWithoutEventInput = {
+    create?: XOR<TagCreateWithoutEventInput, TagUncheckedCreateWithoutEventInput> | TagCreateWithoutEventInput[] | TagUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TagCreateOrConnectWithoutEventInput | TagCreateOrConnectWithoutEventInput[]
+    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
+  }
+
+  export type EventTicketUncheckedCreateNestedManyWithoutEventInput = {
+    create?: XOR<EventTicketCreateWithoutEventInput, EventTicketUncheckedCreateWithoutEventInput> | EventTicketCreateWithoutEventInput[] | EventTicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: EventTicketCreateOrConnectWithoutEventInput | EventTicketCreateOrConnectWithoutEventInput[]
+    createMany?: EventTicketCreateManyEventInputEnvelope
+    connect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
   }
 
   export type EventFolderUpdateOneWithoutEventsNestedInput = {
@@ -18232,6 +19808,20 @@ export namespace Prisma {
     update?: XOR<XOR<EventUpdateToOneWithWhereWithoutSubEventsInput, EventUpdateWithoutSubEventsInput>, EventUncheckedUpdateWithoutSubEventsInput>
   }
 
+  export type TicketUpdateManyWithoutEventNestedInput = {
+    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
+    upsert?: TicketUpsertWithWhereUniqueWithoutEventInput | TicketUpsertWithWhereUniqueWithoutEventInput[]
+    createMany?: TicketCreateManyEventInputEnvelope
+    set?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    disconnect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    delete?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    update?: TicketUpdateWithWhereUniqueWithoutEventInput | TicketUpdateWithWhereUniqueWithoutEventInput[]
+    updateMany?: TicketUpdateManyWithWhereWithoutEventInput | TicketUpdateManyWithWhereWithoutEventInput[]
+    deleteMany?: TicketScalarWhereInput | TicketScalarWhereInput[]
+  }
+
   export type EventUpdateManyWithoutSupraEventNestedInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18246,7 +19836,34 @@ export namespace Prisma {
     deleteMany?: EventScalarWhereInput | EventScalarWhereInput[]
   }
 
-  export type TicketUpdateManyWithoutEventNestedInput = {
+  export type TagUpdateManyWithoutEventNestedInput = {
+    create?: XOR<TagCreateWithoutEventInput, TagUncheckedCreateWithoutEventInput> | TagCreateWithoutEventInput[] | TagUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TagCreateOrConnectWithoutEventInput | TagCreateOrConnectWithoutEventInput[]
+    upsert?: TagUpsertWithWhereUniqueWithoutEventInput | TagUpsertWithWhereUniqueWithoutEventInput[]
+    set?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    disconnect?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    delete?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    update?: TagUpdateWithWhereUniqueWithoutEventInput | TagUpdateWithWhereUniqueWithoutEventInput[]
+    updateMany?: TagUpdateManyWithWhereWithoutEventInput | TagUpdateManyWithWhereWithoutEventInput[]
+    deleteMany?: TagScalarWhereInput | TagScalarWhereInput[]
+  }
+
+  export type EventTicketUpdateManyWithoutEventNestedInput = {
+    create?: XOR<EventTicketCreateWithoutEventInput, EventTicketUncheckedCreateWithoutEventInput> | EventTicketCreateWithoutEventInput[] | EventTicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: EventTicketCreateOrConnectWithoutEventInput | EventTicketCreateOrConnectWithoutEventInput[]
+    upsert?: EventTicketUpsertWithWhereUniqueWithoutEventInput | EventTicketUpsertWithWhereUniqueWithoutEventInput[]
+    createMany?: EventTicketCreateManyEventInputEnvelope
+    set?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    disconnect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    delete?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    connect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    update?: EventTicketUpdateWithWhereUniqueWithoutEventInput | EventTicketUpdateWithWhereUniqueWithoutEventInput[]
+    updateMany?: EventTicketUpdateManyWithWhereWithoutEventInput | EventTicketUpdateManyWithWhereWithoutEventInput[]
+    deleteMany?: EventTicketScalarWhereInput | EventTicketScalarWhereInput[]
+  }
+
+  export type TicketUncheckedUpdateManyWithoutEventNestedInput = {
     create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
     connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
     upsert?: TicketUpsertWithWhereUniqueWithoutEventInput | TicketUpsertWithWhereUniqueWithoutEventInput[]
@@ -18274,18 +19891,31 @@ export namespace Prisma {
     deleteMany?: EventScalarWhereInput | EventScalarWhereInput[]
   }
 
-  export type TicketUncheckedUpdateManyWithoutEventNestedInput = {
-    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
-    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
-    upsert?: TicketUpsertWithWhereUniqueWithoutEventInput | TicketUpsertWithWhereUniqueWithoutEventInput[]
-    createMany?: TicketCreateManyEventInputEnvelope
-    set?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
-    disconnect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
-    delete?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
-    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
-    update?: TicketUpdateWithWhereUniqueWithoutEventInput | TicketUpdateWithWhereUniqueWithoutEventInput[]
-    updateMany?: TicketUpdateManyWithWhereWithoutEventInput | TicketUpdateManyWithWhereWithoutEventInput[]
-    deleteMany?: TicketScalarWhereInput | TicketScalarWhereInput[]
+  export type TagUncheckedUpdateManyWithoutEventNestedInput = {
+    create?: XOR<TagCreateWithoutEventInput, TagUncheckedCreateWithoutEventInput> | TagCreateWithoutEventInput[] | TagUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TagCreateOrConnectWithoutEventInput | TagCreateOrConnectWithoutEventInput[]
+    upsert?: TagUpsertWithWhereUniqueWithoutEventInput | TagUpsertWithWhereUniqueWithoutEventInput[]
+    set?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    disconnect?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    delete?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
+    update?: TagUpdateWithWhereUniqueWithoutEventInput | TagUpdateWithWhereUniqueWithoutEventInput[]
+    updateMany?: TagUpdateManyWithWhereWithoutEventInput | TagUpdateManyWithWhereWithoutEventInput[]
+    deleteMany?: TagScalarWhereInput | TagScalarWhereInput[]
+  }
+
+  export type EventTicketUncheckedUpdateManyWithoutEventNestedInput = {
+    create?: XOR<EventTicketCreateWithoutEventInput, EventTicketUncheckedCreateWithoutEventInput> | EventTicketCreateWithoutEventInput[] | EventTicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: EventTicketCreateOrConnectWithoutEventInput | EventTicketCreateOrConnectWithoutEventInput[]
+    upsert?: EventTicketUpsertWithWhereUniqueWithoutEventInput | EventTicketUpsertWithWhereUniqueWithoutEventInput[]
+    createMany?: EventTicketCreateManyEventInputEnvelope
+    set?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    disconnect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    delete?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    connect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
+    update?: EventTicketUpdateWithWhereUniqueWithoutEventInput | EventTicketUpdateWithWhereUniqueWithoutEventInput[]
+    updateMany?: EventTicketUpdateManyWithWhereWithoutEventInput | EventTicketUpdateManyWithWhereWithoutEventInput[]
+    deleteMany?: EventTicketScalarWhereInput | EventTicketScalarWhereInput[]
   }
 
   export type EventCreateNestedManyWithoutFolderInput = {
@@ -18378,6 +20008,28 @@ export namespace Prisma {
     set?: $Enums.TemplateCategory
   }
 
+  export type EventCreateNestedOneWithoutEventTicketsInput = {
+    create?: XOR<EventCreateWithoutEventTicketsInput, EventUncheckedCreateWithoutEventTicketsInput>
+    connectOrCreate?: EventCreateOrConnectWithoutEventTicketsInput
+    connect?: EventWhereUniqueInput
+  }
+
+  export type NullableFloatFieldUpdateOperationsInput = {
+    set?: number | null
+    increment?: number
+    decrement?: number
+    multiply?: number
+    divide?: number
+  }
+
+  export type EventUpdateOneRequiredWithoutEventTicketsNestedInput = {
+    create?: XOR<EventCreateWithoutEventTicketsInput, EventUncheckedCreateWithoutEventTicketsInput>
+    connectOrCreate?: EventCreateOrConnectWithoutEventTicketsInput
+    upsert?: EventUpsertWithoutEventTicketsInput
+    connect?: EventWhereUniqueInput
+    update?: XOR<XOR<EventUpdateToOneWithWhereWithoutEventTicketsInput, EventUpdateWithoutEventTicketsInput>, EventUncheckedUpdateWithoutEventTicketsInput>
+  }
+
   export type NestedStringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -18709,6 +20361,33 @@ export namespace Prisma {
     _max?: NestedEnumTemplateCategoryFilter<$PrismaModel>
   }
 
+  export type NestedFloatNullableFilter<$PrismaModel = never> = {
+    equals?: number | FloatFieldRefInput<$PrismaModel> | null
+    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    lt?: number | FloatFieldRefInput<$PrismaModel>
+    lte?: number | FloatFieldRefInput<$PrismaModel>
+    gt?: number | FloatFieldRefInput<$PrismaModel>
+    gte?: number | FloatFieldRefInput<$PrismaModel>
+    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
+  }
+
+  export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: number | FloatFieldRefInput<$PrismaModel> | null
+    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
+    lt?: number | FloatFieldRefInput<$PrismaModel>
+    lte?: number | FloatFieldRefInput<$PrismaModel>
+    gt?: number | FloatFieldRefInput<$PrismaModel>
+    gte?: number | FloatFieldRefInput<$PrismaModel>
+    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
+    _count?: NestedIntNullableFilter<$PrismaModel>
+    _avg?: NestedFloatNullableFilter<$PrismaModel>
+    _sum?: NestedFloatNullableFilter<$PrismaModel>
+    _min?: NestedFloatNullableFilter<$PrismaModel>
+    _max?: NestedFloatNullableFilter<$PrismaModel>
+  }
+
   export type CommentCreateWithoutAccountInput = {
     id?: string
     content: string
@@ -18788,6 +20467,7 @@ export namespace Prisma {
     confirmedEvent?: EventCreateNestedOneWithoutTagConfirmedInput
     profiles?: ProfileCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateWithoutAccountsInput = {
@@ -18801,6 +20481,7 @@ export namespace Prisma {
     confirmedEvent?: EventUncheckedCreateNestedOneWithoutTagConfirmedInput
     profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagCreateOrConnectWithoutAccountsInput = {
@@ -18819,6 +20500,7 @@ export namespace Prisma {
     confirmedEvent?: EventCreateNestedOneWithoutTagConfirmedInput
     accounts?: AccountCreateNestedManyWithoutTagsInput
     profiles?: ProfileCreateNestedManyWithoutTagsInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateWithoutAccountsGlobalFilterInput = {
@@ -18832,6 +20514,7 @@ export namespace Prisma {
     confirmedEvent?: EventUncheckedCreateNestedOneWithoutTagConfirmedInput
     accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
     profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagCreateOrConnectWithoutAccountsGlobalFilterInput = {
@@ -19004,6 +20687,7 @@ export namespace Prisma {
     confirmedEvent?: EventCreateNestedOneWithoutTagConfirmedInput
     accounts?: AccountCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateWithoutProfilesInput = {
@@ -19017,6 +20701,7 @@ export namespace Prisma {
     confirmedEvent?: EventUncheckedCreateNestedOneWithoutTagConfirmedInput
     accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagCreateOrConnectWithoutProfilesInput = {
@@ -19669,28 +21354,38 @@ export namespace Prisma {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
-    subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTagAssistedInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
-    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTagAssistedInput = {
@@ -19702,28 +21397,38 @@ export namespace Prisma {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
-    subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTagConfirmedInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
-    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTagConfirmedInput = {
@@ -19850,6 +21555,49 @@ export namespace Prisma {
     create: XOR<AccountCreateWithoutGlobalFilterInput, AccountUncheckedCreateWithoutGlobalFilterInput>
   }
 
+  export type EventCreateWithoutTagsInput = {
+    id?: string
+    name: string
+    date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
+    location: string
+    active?: boolean
+    created_at?: Date | string
+    updated_at?: Date | string
+    folder?: EventFolderCreateNestedOneWithoutEventsInput
+    tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
+    tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
+    supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
+  }
+
+  export type EventUncheckedCreateWithoutTagsInput = {
+    id?: string
+    name: string
+    date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
+    location: string
+    folderId?: string | null
+    tagAssistedId: string
+    tagConfirmedId: string
+    supraEventId?: string | null
+    active?: boolean
+    created_at?: Date | string
+    updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
+  }
+
+  export type EventCreateOrConnectWithoutTagsInput = {
+    where: EventWhereUniqueInput
+    create: XOR<EventCreateWithoutTagsInput, EventUncheckedCreateWithoutTagsInput>
+  }
+
   export type TagGroupUpsertWithoutTagsInput = {
     update: XOR<TagGroupUpdateWithoutTagsInput, TagGroupUncheckedUpdateWithoutTagsInput>
     create: XOR<TagGroupCreateWithoutTagsInput, TagGroupUncheckedCreateWithoutTagsInput>
@@ -19894,28 +21642,38 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
-    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTagAssistedInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUpsertWithoutTagConfirmedInput = {
@@ -19933,28 +21691,38 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
-    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTagConfirmedInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type AccountUpsertWithWhereUniqueWithoutTagsInput = {
@@ -20019,6 +21787,41 @@ export namespace Prisma {
     data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutGlobalFilterInput>
   }
 
+  export type EventUpsertWithWhereUniqueWithoutTagsInput = {
+    where: EventWhereUniqueInput
+    update: XOR<EventUpdateWithoutTagsInput, EventUncheckedUpdateWithoutTagsInput>
+    create: XOR<EventCreateWithoutTagsInput, EventUncheckedCreateWithoutTagsInput>
+  }
+
+  export type EventUpdateWithWhereUniqueWithoutTagsInput = {
+    where: EventWhereUniqueInput
+    data: XOR<EventUpdateWithoutTagsInput, EventUncheckedUpdateWithoutTagsInput>
+  }
+
+  export type EventUpdateManyWithWhereWithoutTagsInput = {
+    where: EventScalarWhereInput
+    data: XOR<EventUpdateManyMutationInput, EventUncheckedUpdateManyWithoutTagsInput>
+  }
+
+  export type EventScalarWhereInput = {
+    AND?: EventScalarWhereInput | EventScalarWhereInput[]
+    OR?: EventScalarWhereInput[]
+    NOT?: EventScalarWhereInput | EventScalarWhereInput[]
+    id?: StringFilter<"Event"> | string
+    name?: StringFilter<"Event"> | string
+    date?: DateTimeFilter<"Event"> | Date | string
+    startingDate?: DateTimeFilter<"Event"> | Date | string
+    endingDate?: DateTimeFilter<"Event"> | Date | string
+    location?: StringFilter<"Event"> | string
+    folderId?: StringNullableFilter<"Event"> | string | null
+    tagAssistedId?: StringFilter<"Event"> | string
+    tagConfirmedId?: StringFilter<"Event"> | string
+    supraEventId?: StringNullableFilter<"Event"> | string | null
+    active?: BoolFilter<"Event"> | boolean
+    created_at?: DateTimeFilter<"Event"> | Date | string
+    updated_at?: DateTimeFilter<"Event"> | Date | string
+  }
+
   export type TagCreateWithoutGroupInput = {
     id?: string
     name: string
@@ -20030,6 +21833,7 @@ export namespace Prisma {
     accounts?: AccountCreateNestedManyWithoutTagsInput
     profiles?: ProfileCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateWithoutGroupInput = {
@@ -20043,6 +21847,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
     profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagCreateOrConnectWithoutGroupInput = {
@@ -20103,6 +21908,7 @@ export namespace Prisma {
     accounts?: AccountCreateNestedManyWithoutTagsInput
     profiles?: ProfileCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateWithoutAssistedEventInput = {
@@ -20116,6 +21922,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
     profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagCreateOrConnectWithoutAssistedEventInput = {
@@ -20134,6 +21941,7 @@ export namespace Prisma {
     accounts?: AccountCreateNestedManyWithoutTagsInput
     profiles?: ProfileCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventCreateNestedManyWithoutTagsInput
   }
 
   export type TagUncheckedCreateWithoutConfirmedEventInput = {
@@ -20147,6 +21955,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
     profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
     accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+    Event?: EventUncheckedCreateNestedManyWithoutTagsInput
   }
 
   export type TagCreateOrConnectWithoutConfirmedEventInput = {
@@ -20158,7 +21967,10 @@ export namespace Prisma {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     folder?: EventFolderCreateNestedOneWithoutEventsInput
@@ -20166,20 +21978,27 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     tickets?: TicketCreateNestedManyWithoutEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutSubEventsInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutSubEventsInput = {
@@ -20187,32 +22006,72 @@ export namespace Prisma {
     create: XOR<EventCreateWithoutSubEventsInput, EventUncheckedCreateWithoutSubEventsInput>
   }
 
+  export type TicketCreateWithoutEventInput = {
+    id?: string
+    type: $Enums.TicketType
+    status: $Enums.TicketStatus
+    fullName: string
+    mail: string
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
+  export type TicketUncheckedCreateWithoutEventInput = {
+    id?: string
+    type: $Enums.TicketType
+    status: $Enums.TicketStatus
+    fullName: string
+    mail: string
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
+  export type TicketCreateOrConnectWithoutEventInput = {
+    where: TicketWhereUniqueInput
+    create: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput>
+  }
+
+  export type TicketCreateManyEventInputEnvelope = {
+    data: TicketCreateManyEventInput | TicketCreateManyEventInput[]
+    skipDuplicates?: boolean
+  }
+
   export type EventCreateWithoutSupraEventInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
-    subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutSupraEventInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     tagConfirmedId: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
-    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutSupraEventInput = {
@@ -20225,33 +22084,64 @@ export namespace Prisma {
     skipDuplicates?: boolean
   }
 
-  export type TicketCreateWithoutEventInput = {
+  export type TagCreateWithoutEventInput = {
+    id?: string
+    name: string
+    type?: $Enums.TagType
+    created_at?: Date | string
+    updated_at?: Date | string
+    group: TagGroupCreateNestedOneWithoutTagsInput
+    assistedEvent?: EventCreateNestedOneWithoutTagAssistedInput
+    confirmedEvent?: EventCreateNestedOneWithoutTagConfirmedInput
+    accounts?: AccountCreateNestedManyWithoutTagsInput
+    profiles?: ProfileCreateNestedManyWithoutTagsInput
+    accountsGlobalFilter?: AccountCreateNestedManyWithoutGlobalFilterInput
+  }
+
+  export type TagUncheckedCreateWithoutEventInput = {
+    id?: string
+    name: string
+    type?: $Enums.TagType
+    groupId: string
+    created_at?: Date | string
+    updated_at?: Date | string
+    assistedEvent?: EventUncheckedCreateNestedOneWithoutTagAssistedInput
+    confirmedEvent?: EventUncheckedCreateNestedOneWithoutTagConfirmedInput
+    accounts?: AccountUncheckedCreateNestedManyWithoutTagsInput
+    profiles?: ProfileUncheckedCreateNestedManyWithoutTagsInput
+    accountsGlobalFilter?: AccountUncheckedCreateNestedManyWithoutGlobalFilterInput
+  }
+
+  export type TagCreateOrConnectWithoutEventInput = {
+    where: TagWhereUniqueInput
+    create: XOR<TagCreateWithoutEventInput, TagUncheckedCreateWithoutEventInput>
+  }
+
+  export type EventTicketCreateWithoutEventInput = {
     id?: string
+    amount: number
     type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
+    price?: number | null
     created_at?: Date | string
     updated_at?: Date | string
   }
 
-  export type TicketUncheckedCreateWithoutEventInput = {
+  export type EventTicketUncheckedCreateWithoutEventInput = {
     id?: string
+    amount: number
     type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
+    price?: number | null
     created_at?: Date | string
     updated_at?: Date | string
   }
 
-  export type TicketCreateOrConnectWithoutEventInput = {
-    where: TicketWhereUniqueInput
-    create: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput>
+  export type EventTicketCreateOrConnectWithoutEventInput = {
+    where: EventTicketWhereUniqueInput
+    create: XOR<EventTicketCreateWithoutEventInput, EventTicketUncheckedCreateWithoutEventInput>
   }
 
-  export type TicketCreateManyEventInputEnvelope = {
-    data: TicketCreateManyEventInput | TicketCreateManyEventInput[]
+  export type EventTicketCreateManyEventInputEnvelope = {
+    data: EventTicketCreateManyEventInput | EventTicketCreateManyEventInput[]
     skipDuplicates?: boolean
   }
 
@@ -20304,6 +22194,7 @@ export namespace Prisma {
     accounts?: AccountUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateWithoutAssistedEventInput = {
@@ -20317,6 +22208,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUpsertWithoutConfirmedEventInput = {
@@ -20341,6 +22233,7 @@ export namespace Prisma {
     accounts?: AccountUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateWithoutConfirmedEventInput = {
@@ -20354,6 +22247,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type EventUpsertWithoutSubEventsInput = {
@@ -20371,7 +22265,10 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
@@ -20379,54 +22276,29 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     tickets?: TicketUpdateManyWithoutEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
+  }
+
+  export type EventUncheckedUpdateWithoutSubEventsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    folderId?: NullableStringFieldUpdateOperationsInput | string | null
+    tagAssistedId?: StringFieldUpdateOperationsInput | string
+    tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
-  export type EventUncheckedUpdateWithoutSubEventsInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    name?: StringFieldUpdateOperationsInput | string
-    date?: DateTimeFieldUpdateOperationsInput | Date | string
-    location?: StringFieldUpdateOperationsInput | string
-    folderId?: NullableStringFieldUpdateOperationsInput | string | null
-    tagAssistedId?: StringFieldUpdateOperationsInput | string
-    tagConfirmedId?: StringFieldUpdateOperationsInput | string
-    supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
-  }
-
-  export type EventUpsertWithWhereUniqueWithoutSupraEventInput = {
-    where: EventWhereUniqueInput
-    update: XOR<EventUpdateWithoutSupraEventInput, EventUncheckedUpdateWithoutSupraEventInput>
-    create: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput>
-  }
-
-  export type EventUpdateWithWhereUniqueWithoutSupraEventInput = {
-    where: EventWhereUniqueInput
-    data: XOR<EventUpdateWithoutSupraEventInput, EventUncheckedUpdateWithoutSupraEventInput>
-  }
-
-  export type EventUpdateManyWithWhereWithoutSupraEventInput = {
-    where: EventScalarWhereInput
-    data: XOR<EventUpdateManyMutationInput, EventUncheckedUpdateManyWithoutSupraEventInput>
-  }
-
-  export type EventScalarWhereInput = {
-    AND?: EventScalarWhereInput | EventScalarWhereInput[]
-    OR?: EventScalarWhereInput[]
-    NOT?: EventScalarWhereInput | EventScalarWhereInput[]
-    id?: StringFilter<"Event"> | string
-    name?: StringFilter<"Event"> | string
-    date?: DateTimeFilter<"Event"> | Date | string
-    location?: StringFilter<"Event"> | string
-    folderId?: StringNullableFilter<"Event"> | string | null
-    tagAssistedId?: StringFilter<"Event"> | string
-    tagConfirmedId?: StringFilter<"Event"> | string
-    supraEventId?: StringNullableFilter<"Event"> | string | null
-    created_at?: DateTimeFilter<"Event"> | Date | string
-    updated_at?: DateTimeFilter<"Event"> | Date | string
-  }
-
   export type TicketUpsertWithWhereUniqueWithoutEventInput = {
     where: TicketWhereUniqueInput
     update: XOR<TicketUpdateWithoutEventInput, TicketUncheckedUpdateWithoutEventInput>
@@ -20457,32 +22329,103 @@ export namespace Prisma {
     updated_at?: DateTimeFilter<"Ticket"> | Date | string
   }
 
+  export type EventUpsertWithWhereUniqueWithoutSupraEventInput = {
+    where: EventWhereUniqueInput
+    update: XOR<EventUpdateWithoutSupraEventInput, EventUncheckedUpdateWithoutSupraEventInput>
+    create: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput>
+  }
+
+  export type EventUpdateWithWhereUniqueWithoutSupraEventInput = {
+    where: EventWhereUniqueInput
+    data: XOR<EventUpdateWithoutSupraEventInput, EventUncheckedUpdateWithoutSupraEventInput>
+  }
+
+  export type EventUpdateManyWithWhereWithoutSupraEventInput = {
+    where: EventScalarWhereInput
+    data: XOR<EventUpdateManyMutationInput, EventUncheckedUpdateManyWithoutSupraEventInput>
+  }
+
+  export type TagUpsertWithWhereUniqueWithoutEventInput = {
+    where: TagWhereUniqueInput
+    update: XOR<TagUpdateWithoutEventInput, TagUncheckedUpdateWithoutEventInput>
+    create: XOR<TagCreateWithoutEventInput, TagUncheckedCreateWithoutEventInput>
+  }
+
+  export type TagUpdateWithWhereUniqueWithoutEventInput = {
+    where: TagWhereUniqueInput
+    data: XOR<TagUpdateWithoutEventInput, TagUncheckedUpdateWithoutEventInput>
+  }
+
+  export type TagUpdateManyWithWhereWithoutEventInput = {
+    where: TagScalarWhereInput
+    data: XOR<TagUpdateManyMutationInput, TagUncheckedUpdateManyWithoutEventInput>
+  }
+
+  export type EventTicketUpsertWithWhereUniqueWithoutEventInput = {
+    where: EventTicketWhereUniqueInput
+    update: XOR<EventTicketUpdateWithoutEventInput, EventTicketUncheckedUpdateWithoutEventInput>
+    create: XOR<EventTicketCreateWithoutEventInput, EventTicketUncheckedCreateWithoutEventInput>
+  }
+
+  export type EventTicketUpdateWithWhereUniqueWithoutEventInput = {
+    where: EventTicketWhereUniqueInput
+    data: XOR<EventTicketUpdateWithoutEventInput, EventTicketUncheckedUpdateWithoutEventInput>
+  }
+
+  export type EventTicketUpdateManyWithWhereWithoutEventInput = {
+    where: EventTicketScalarWhereInput
+    data: XOR<EventTicketUpdateManyMutationInput, EventTicketUncheckedUpdateManyWithoutEventInput>
+  }
+
+  export type EventTicketScalarWhereInput = {
+    AND?: EventTicketScalarWhereInput | EventTicketScalarWhereInput[]
+    OR?: EventTicketScalarWhereInput[]
+    NOT?: EventTicketScalarWhereInput | EventTicketScalarWhereInput[]
+    id?: StringFilter<"EventTicket"> | string
+    eventId?: StringFilter<"EventTicket"> | string
+    amount?: IntFilter<"EventTicket"> | number
+    type?: EnumTicketTypeFilter<"EventTicket"> | $Enums.TicketType
+    price?: FloatNullableFilter<"EventTicket"> | number | null
+    created_at?: DateTimeFilter<"EventTicket"> | Date | string
+    updated_at?: DateTimeFilter<"EventTicket"> | Date | string
+  }
+
   export type EventCreateWithoutFolderInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
-    subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutFolderInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
-    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutFolderInput = {
@@ -20627,7 +22570,10 @@ export namespace Prisma {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     folder?: EventFolderCreateNestedOneWithoutEventsInput
@@ -20635,20 +22581,27 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTicketsInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTicketsInput = {
@@ -20671,7 +22624,10 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
@@ -20679,20 +22635,119 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTicketsInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    folderId?: NullableStringFieldUpdateOperationsInput | string | null
+    tagAssistedId?: StringFieldUpdateOperationsInput | string
+    tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
+  }
+
+  export type EventCreateWithoutEventTicketsInput = {
+    id?: string
+    name: string
+    date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
+    location: string
+    active?: boolean
+    created_at?: Date | string
+    updated_at?: Date | string
+    folder?: EventFolderCreateNestedOneWithoutEventsInput
+    tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
+    tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
+    supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+  }
+
+  export type EventUncheckedCreateWithoutEventTicketsInput = {
+    id?: string
+    name: string
+    date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
+    location: string
+    folderId?: string | null
+    tagAssistedId: string
+    tagConfirmedId: string
+    supraEventId?: string | null
+    active?: boolean
+    created_at?: Date | string
+    updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+  }
+
+  export type EventCreateOrConnectWithoutEventTicketsInput = {
+    where: EventWhereUniqueInput
+    create: XOR<EventCreateWithoutEventTicketsInput, EventUncheckedCreateWithoutEventTicketsInput>
+  }
+
+  export type EventUpsertWithoutEventTicketsInput = {
+    update: XOR<EventUpdateWithoutEventTicketsInput, EventUncheckedUpdateWithoutEventTicketsInput>
+    create: XOR<EventCreateWithoutEventTicketsInput, EventUncheckedCreateWithoutEventTicketsInput>
+    where?: EventWhereInput
+  }
+
+  export type EventUpdateToOneWithWhereWithoutEventTicketsInput = {
+    where?: EventWhereInput
+    data: XOR<EventUpdateWithoutEventTicketsInput, EventUncheckedUpdateWithoutEventTicketsInput>
+  }
+
+  export type EventUpdateWithoutEventTicketsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    folder?: EventFolderUpdateOneWithoutEventsNestedInput
+    tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
+    tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
+    supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+  }
+
+  export type EventUncheckedUpdateWithoutEventTicketsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type CommentCreateManyAccountInput = {
@@ -20802,6 +22857,7 @@ export namespace Prisma {
     confirmedEvent?: EventUpdateOneWithoutTagConfirmedNestedInput
     profiles?: ProfileUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateWithoutAccountsInput = {
@@ -20815,6 +22871,7 @@ export namespace Prisma {
     confirmedEvent?: EventUncheckedUpdateOneWithoutTagConfirmedNestedInput
     profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateManyWithoutAccountsInput = {
@@ -20837,6 +22894,7 @@ export namespace Prisma {
     confirmedEvent?: EventUpdateOneWithoutTagConfirmedNestedInput
     accounts?: AccountUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUpdateManyWithoutTagsNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateWithoutAccountsGlobalFilterInput = {
@@ -20850,6 +22908,7 @@ export namespace Prisma {
     confirmedEvent?: EventUncheckedUpdateOneWithoutTagConfirmedNestedInput
     accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateManyWithoutAccountsGlobalFilterInput = {
@@ -20956,6 +23015,7 @@ export namespace Prisma {
     confirmedEvent?: EventUpdateOneWithoutTagConfirmedNestedInput
     accounts?: AccountUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateWithoutProfilesInput = {
@@ -20969,6 +23029,7 @@ export namespace Prisma {
     confirmedEvent?: EventUncheckedUpdateOneWithoutTagConfirmedNestedInput
     accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateManyWithoutProfilesInput = {
@@ -21308,6 +23369,60 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
+  export type EventUpdateWithoutTagsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    folder?: EventFolderUpdateOneWithoutEventsNestedInput
+    tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
+    tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
+    supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
+  }
+
+  export type EventUncheckedUpdateWithoutTagsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    folderId?: NullableStringFieldUpdateOperationsInput | string | null
+    tagAssistedId?: StringFieldUpdateOperationsInput | string
+    tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
+  }
+
+  export type EventUncheckedUpdateManyWithoutTagsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    folderId?: NullableStringFieldUpdateOperationsInput | string | null
+    tagAssistedId?: StringFieldUpdateOperationsInput | string
+    tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
   export type TagCreateManyGroupInput = {
     id?: string
     name: string
@@ -21327,6 +23442,7 @@ export namespace Prisma {
     accounts?: AccountUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateWithoutGroupInput = {
@@ -21340,6 +23456,7 @@ export namespace Prisma {
     accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
     profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
     accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+    Event?: EventUncheckedUpdateManyWithoutTagsNestedInput
   }
 
   export type TagUncheckedUpdateManyWithoutGroupInput = {
@@ -21350,94 +23467,183 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
+  export type TicketCreateManyEventInput = {
+    id?: string
+    type: $Enums.TicketType
+    status: $Enums.TicketStatus
+    fullName: string
+    mail: string
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
   export type EventCreateManySupraEventInput = {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     folderId?: string | null
     tagAssistedId: string
     tagConfirmedId: string
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
   }
 
-  export type TicketCreateManyEventInput = {
+  export type EventTicketCreateManyEventInput = {
     id?: string
+    amount: number
     type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
+    price?: number | null
     created_at?: Date | string
     updated_at?: Date | string
   }
 
+  export type TicketUpdateWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
+    fullName?: StringFieldUpdateOperationsInput | string
+    mail?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type TicketUncheckedUpdateWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
+    fullName?: StringFieldUpdateOperationsInput | string
+    mail?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type TicketUncheckedUpdateManyWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
+    fullName?: StringFieldUpdateOperationsInput | string
+    mail?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
   export type EventUpdateWithoutSupraEventInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
-    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutSupraEventInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateManyWithoutSupraEventInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     folderId?: NullableStringFieldUpdateOperationsInput | string | null
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type TicketUpdateWithoutEventInput = {
+  export type TagUpdateWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    type?: EnumTagTypeFieldUpdateOperationsInput | $Enums.TagType
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    group?: TagGroupUpdateOneRequiredWithoutTagsNestedInput
+    assistedEvent?: EventUpdateOneWithoutTagAssistedNestedInput
+    confirmedEvent?: EventUpdateOneWithoutTagConfirmedNestedInput
+    accounts?: AccountUpdateManyWithoutTagsNestedInput
+    profiles?: ProfileUpdateManyWithoutTagsNestedInput
+    accountsGlobalFilter?: AccountUpdateManyWithoutGlobalFilterNestedInput
+  }
+
+  export type TagUncheckedUpdateWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    type?: EnumTagTypeFieldUpdateOperationsInput | $Enums.TagType
+    groupId?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    assistedEvent?: EventUncheckedUpdateOneWithoutTagAssistedNestedInput
+    confirmedEvent?: EventUncheckedUpdateOneWithoutTagConfirmedNestedInput
+    accounts?: AccountUncheckedUpdateManyWithoutTagsNestedInput
+    profiles?: ProfileUncheckedUpdateManyWithoutTagsNestedInput
+    accountsGlobalFilter?: AccountUncheckedUpdateManyWithoutGlobalFilterNestedInput
+  }
+
+  export type TagUncheckedUpdateManyWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    type?: EnumTagTypeFieldUpdateOperationsInput | $Enums.TagType
+    groupId?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type EventTicketUpdateWithoutEventInput = {
     id?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
     type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
-    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
-    fullName?: StringFieldUpdateOperationsInput | string
-    mail?: StringFieldUpdateOperationsInput | string
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type TicketUncheckedUpdateWithoutEventInput = {
+  export type EventTicketUncheckedUpdateWithoutEventInput = {
     id?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
     type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
-    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
-    fullName?: StringFieldUpdateOperationsInput | string
-    mail?: StringFieldUpdateOperationsInput | string
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type TicketUncheckedUpdateManyWithoutEventInput = {
+  export type EventTicketUncheckedUpdateManyWithoutEventInput = {
     id?: StringFieldUpdateOperationsInput | string
+    amount?: IntFieldUpdateOperationsInput | number
     type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
-    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
-    fullName?: StringFieldUpdateOperationsInput | string
-    mail?: StringFieldUpdateOperationsInput | string
+    price?: NullableFloatFieldUpdateOperationsInput | number | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -21446,10 +23652,13 @@ export namespace Prisma {
     id?: string
     name: string
     date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
     location: string
     tagAssistedId: string
     tagConfirmedId: string
     supraEventId?: string | null
+    active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
   }
@@ -21458,38 +23667,51 @@ export namespace Prisma {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
-    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUpdateManyWithoutEventNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutFolderInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateManyWithoutFolderInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
     date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
     location?: StringFieldUpdateOperationsInput | string
     tagAssistedId?: StringFieldUpdateOperationsInput | string
     tagConfirmedId?: StringFieldUpdateOperationsInput | string
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
@@ -21575,6 +23797,10 @@ export namespace Prisma {
      * @deprecated Use EnumsDefaultArgs instead
      */
     export type EnumsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EnumsDefaultArgs<ExtArgs>
+    /**
+     * @deprecated Use EventTicketDefaultArgs instead
+     */
+    export type EventTicketArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EventTicketDefaultArgs<ExtArgs>
 
   /**
    * Batch Payload for updateMany & deleteMany & createMany