expo-backend-types 0.31.0-EXPO-317-EB-CRUD-Tickets.5 → 0.31.0

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

@@ -63,11 +63,6 @@ export type Message = $Result.DefaultSelection<Prisma.$MessagePayload>
  * 
  */
 export type CannedResponse = $Result.DefaultSelection<Prisma.$CannedResponsePayload>
-/**
- * Model Ticket
- * 
- */
-export type Ticket = $Result.DefaultSelection<Prisma.$TicketPayload>
 /**
  * Model Enums
  * 
@@ -106,23 +101,6 @@ export const MessageState: {
 export type MessageState = (typeof MessageState)[keyof typeof MessageState]
 
 
-export const TicketType: {
-  PARTICIPANT: 'PARTICIPANT',
-  SPECTATOR: 'SPECTATOR',
-  STAFF: 'STAFF'
-};
-
-export type TicketType = (typeof TicketType)[keyof typeof TicketType]
-
-
-export const TicketStatus: {
-  BOOKED: 'BOOKED',
-  PAID: 'PAID'
-};
-
-export type TicketStatus = (typeof TicketStatus)[keyof typeof TicketStatus]
-
-
 export const TemplateStatus: {
   APPROVED: 'APPROVED',
   PENDING: 'PENDING',
@@ -154,14 +132,6 @@ export type MessageState = $Enums.MessageState
 
 export const MessageState: typeof $Enums.MessageState
 
-export type TicketType = $Enums.TicketType
-
-export const TicketType: typeof $Enums.TicketType
-
-export type TicketStatus = $Enums.TicketStatus
-
-export const TicketStatus: typeof $Enums.TicketStatus
-
 export type TemplateStatus = $Enums.TemplateStatus
 
 export const TemplateStatus: typeof $Enums.TemplateStatus
@@ -393,16 +363,6 @@ export class PrismaClient<
     */
   get cannedResponse(): Prisma.CannedResponseDelegate<ExtArgs>;
 
-  /**
-   * `prisma.ticket`: Exposes CRUD operations for the **Ticket** model.
-    * Example usage:
-    * ```ts
-    * // Fetch zero or more Tickets
-    * const tickets = await prisma.ticket.findMany()
-    * ```
-    */
-  get ticket(): Prisma.TicketDelegate<ExtArgs>;
-
   /**
    * `prisma.enums`: Exposes CRUD operations for the **Enums** model.
     * Example usage:
@@ -863,7 +823,6 @@ export namespace Prisma {
     EventFolder: 'EventFolder',
     Message: 'Message',
     CannedResponse: 'CannedResponse',
-    Ticket: 'Ticket',
     Enums: 'Enums'
   };
 
@@ -880,7 +839,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" | "enums"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -1584,76 +1543,6 @@ export namespace Prisma {
           }
         }
       }
-      Ticket: {
-        payload: Prisma.$TicketPayload<ExtArgs>
-        fields: Prisma.TicketFieldRefs
-        operations: {
-          findUnique: {
-            args: Prisma.TicketFindUniqueArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload> | null
-          }
-          findUniqueOrThrow: {
-            args: Prisma.TicketFindUniqueOrThrowArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>
-          }
-          findFirst: {
-            args: Prisma.TicketFindFirstArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload> | null
-          }
-          findFirstOrThrow: {
-            args: Prisma.TicketFindFirstOrThrowArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>
-          }
-          findMany: {
-            args: Prisma.TicketFindManyArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>[]
-          }
-          create: {
-            args: Prisma.TicketCreateArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>
-          }
-          createMany: {
-            args: Prisma.TicketCreateManyArgs<ExtArgs>
-            result: BatchPayload
-          }
-          createManyAndReturn: {
-            args: Prisma.TicketCreateManyAndReturnArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>[]
-          }
-          delete: {
-            args: Prisma.TicketDeleteArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>
-          }
-          update: {
-            args: Prisma.TicketUpdateArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>
-          }
-          deleteMany: {
-            args: Prisma.TicketDeleteManyArgs<ExtArgs>
-            result: BatchPayload
-          }
-          updateMany: {
-            args: Prisma.TicketUpdateManyArgs<ExtArgs>
-            result: BatchPayload
-          }
-          upsert: {
-            args: Prisma.TicketUpsertArgs<ExtArgs>
-            result: $Utils.PayloadToResult<Prisma.$TicketPayload>
-          }
-          aggregate: {
-            args: Prisma.TicketAggregateArgs<ExtArgs>
-            result: $Utils.Optional<AggregateTicket>
-          }
-          groupBy: {
-            args: Prisma.TicketGroupByArgs<ExtArgs>
-            result: $Utils.Optional<TicketGroupByOutputType>[]
-          }
-          count: {
-            args: Prisma.TicketCountArgs<ExtArgs>
-            result: $Utils.Optional<TicketCountAggregateOutputType> | number
-          }
-        }
-      }
       Enums: {
         payload: Prisma.$EnumsPayload<ExtArgs>
         fields: Prisma.EnumsFieldRefs
@@ -2113,12 +2002,10 @@ export namespace Prisma {
 
   export type EventCountOutputType = {
     subEvents: number
-    tickets: number
   }
 
   export type EventCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     subEvents?: boolean | EventCountOutputTypeCountSubEventsArgs
-    tickets?: boolean | EventCountOutputTypeCountTicketsArgs
   }
 
   // Custom InputTypes
@@ -2139,13 +2026,6 @@ export namespace Prisma {
     where?: EventWhereInput
   }
 
-  /**
-   * EventCountOutputType without action
-   */
-  export type EventCountOutputTypeCountTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: TicketWhereInput
-  }
-
 
   /**
    * Count Type EventFolderCountOutputType
@@ -8767,7 +8647,6 @@ export namespace Prisma {
     tagConfirmed?: boolean | TagDefaultArgs<ExtArgs>
     supraEvent?: boolean | Event$supraEventArgs<ExtArgs>
     subEvents?: boolean | Event$subEventsArgs<ExtArgs>
-    tickets?: boolean | Event$ticketsArgs<ExtArgs>
     _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["event"]>
 
@@ -8807,7 +8686,6 @@ export namespace Prisma {
     tagConfirmed?: boolean | TagDefaultArgs<ExtArgs>
     supraEvent?: boolean | Event$supraEventArgs<ExtArgs>
     subEvents?: boolean | Event$subEventsArgs<ExtArgs>
-    tickets?: boolean | Event$ticketsArgs<ExtArgs>
     _count?: boolean | EventCountOutputTypeDefaultArgs<ExtArgs>
   }
   export type EventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
@@ -8825,7 +8703,6 @@ export namespace Prisma {
       tagConfirmed: Prisma.$TagPayload<ExtArgs>
       supraEvent: Prisma.$EventPayload<ExtArgs> | null
       subEvents: Prisma.$EventPayload<ExtArgs>[]
-      tickets: Prisma.$TicketPayload<ExtArgs>[]
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
@@ -9207,7 +9084,6 @@ export namespace Prisma {
     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>
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
      * @param onfulfilled The callback to execute when the Promise is resolved.
@@ -9614,26 +9490,6 @@ export namespace Prisma {
     distinct?: EventScalarFieldEnum | EventScalarFieldEnum[]
   }
 
-  /**
-   * 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 without action
    */
@@ -12429,370 +12285,305 @@ export namespace Prisma {
 
 
   /**
-   * Model Ticket
+   * Model Enums
    */
 
-  export type AggregateTicket = {
-    _count: TicketCountAggregateOutputType | null
-    _min: TicketMinAggregateOutputType | null
-    _max: TicketMaxAggregateOutputType | null
+  export type AggregateEnums = {
+    _count: EnumsCountAggregateOutputType | null
+    _min: EnumsMinAggregateOutputType | null
+    _max: EnumsMaxAggregateOutputType | null
   }
 
-  export type TicketMinAggregateOutputType = {
+  export type EnumsMinAggregateOutputType = {
     id: string | null
-    eventId: string | null
-    type: $Enums.TicketType | null
-    status: $Enums.TicketStatus | null
-    fullName: string | null
-    mail: string | null
-    created_at: Date | null
-    updated_at: Date | null
+    templateStatus: $Enums.TemplateStatus | null
+    templateCategory: $Enums.TemplateCategory | null
   }
 
-  export type TicketMaxAggregateOutputType = {
+  export type EnumsMaxAggregateOutputType = {
     id: string | null
-    eventId: string | null
-    type: $Enums.TicketType | null
-    status: $Enums.TicketStatus | null
-    fullName: string | null
-    mail: string | null
-    created_at: Date | null
-    updated_at: Date | null
+    templateStatus: $Enums.TemplateStatus | null
+    templateCategory: $Enums.TemplateCategory | null
   }
 
-  export type TicketCountAggregateOutputType = {
+  export type EnumsCountAggregateOutputType = {
     id: number
-    eventId: number
-    type: number
-    status: number
-    fullName: number
-    mail: number
-    created_at: number
-    updated_at: number
+    templateStatus: number
+    templateCategory: number
     _all: number
   }
 
 
-  export type TicketMinAggregateInputType = {
+  export type EnumsMinAggregateInputType = {
     id?: true
-    eventId?: true
-    type?: true
-    status?: true
-    fullName?: true
-    mail?: true
-    created_at?: true
-    updated_at?: true
+    templateStatus?: true
+    templateCategory?: true
   }
 
-  export type TicketMaxAggregateInputType = {
+  export type EnumsMaxAggregateInputType = {
     id?: true
-    eventId?: true
-    type?: true
-    status?: true
-    fullName?: true
-    mail?: true
-    created_at?: true
-    updated_at?: true
+    templateStatus?: true
+    templateCategory?: true
   }
 
-  export type TicketCountAggregateInputType = {
+  export type EnumsCountAggregateInputType = {
     id?: true
-    eventId?: true
-    type?: true
-    status?: true
-    fullName?: true
-    mail?: true
-    created_at?: true
-    updated_at?: true
+    templateStatus?: true
+    templateCategory?: true
     _all?: true
   }
 
-  export type TicketAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type EnumsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Filter which Ticket to aggregate.
+     * Filter which Enums to aggregate.
      */
-    where?: TicketWhereInput
+    where?: EnumsWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of Tickets to fetch.
+     * Determine the order of Enums to fetch.
      */
-    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
+    orderBy?: EnumsOrderByWithRelationInput | EnumsOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
      * Sets the start position
      */
-    cursor?: TicketWhereUniqueInput
+    cursor?: EnumsWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` Tickets from the position of the cursor.
+     * Take `±n` Enums 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` Tickets.
+     * Skip the first `n` Enums.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
-     * Count returned Tickets
+     * Count returned Enums
     **/
-    _count?: true | TicketCountAggregateInputType
+    _count?: true | EnumsCountAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the minimum value
     **/
-    _min?: TicketMinAggregateInputType
+    _min?: EnumsMinAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the maximum value
     **/
-    _max?: TicketMaxAggregateInputType
+    _max?: EnumsMaxAggregateInputType
   }
 
-  export type GetTicketAggregateType<T extends TicketAggregateArgs> = {
-        [P in keyof T & keyof AggregateTicket]: P extends '_count' | 'count'
+  export type GetEnumsAggregateType<T extends EnumsAggregateArgs> = {
+        [P in keyof T & keyof AggregateEnums]: P extends '_count' | 'count'
       ? T[P] extends true
         ? number
-        : GetScalarType<T[P], AggregateTicket[P]>
-      : GetScalarType<T[P], AggregateTicket[P]>
+        : GetScalarType<T[P], AggregateEnums[P]>
+      : GetScalarType<T[P], AggregateEnums[P]>
   }
 
 
 
 
-  export type TicketGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: TicketWhereInput
-    orderBy?: TicketOrderByWithAggregationInput | TicketOrderByWithAggregationInput[]
-    by: TicketScalarFieldEnum[] | TicketScalarFieldEnum
-    having?: TicketScalarWhereWithAggregatesInput
+  export type EnumsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: EnumsWhereInput
+    orderBy?: EnumsOrderByWithAggregationInput | EnumsOrderByWithAggregationInput[]
+    by: EnumsScalarFieldEnum[] | EnumsScalarFieldEnum
+    having?: EnumsScalarWhereWithAggregatesInput
     take?: number
     skip?: number
-    _count?: TicketCountAggregateInputType | true
-    _min?: TicketMinAggregateInputType
-    _max?: TicketMaxAggregateInputType
+    _count?: EnumsCountAggregateInputType | true
+    _min?: EnumsMinAggregateInputType
+    _max?: EnumsMaxAggregateInputType
   }
 
-  export type TicketGroupByOutputType = {
+  export type EnumsGroupByOutputType = {
     id: string
-    eventId: string
-    type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
-    created_at: Date
-    updated_at: Date
-    _count: TicketCountAggregateOutputType | null
-    _min: TicketMinAggregateOutputType | null
-    _max: TicketMaxAggregateOutputType | null
+    templateStatus: $Enums.TemplateStatus
+    templateCategory: $Enums.TemplateCategory
+    _count: EnumsCountAggregateOutputType | null
+    _min: EnumsMinAggregateOutputType | null
+    _max: EnumsMaxAggregateOutputType | null
   }
 
-  type GetTicketGroupByPayload<T extends TicketGroupByArgs> = Prisma.PrismaPromise<
+  type GetEnumsGroupByPayload<T extends EnumsGroupByArgs> = Prisma.PrismaPromise<
     Array<
-      PickEnumerable<TicketGroupByOutputType, T['by']> &
+      PickEnumerable<EnumsGroupByOutputType, T['by']> &
         {
-          [P in ((keyof T) & (keyof TicketGroupByOutputType))]: P extends '_count'
+          [P in ((keyof T) & (keyof EnumsGroupByOutputType))]: P extends '_count'
             ? T[P] extends boolean
               ? number
-              : GetScalarType<T[P], TicketGroupByOutputType[P]>
-            : GetScalarType<T[P], TicketGroupByOutputType[P]>
+              : GetScalarType<T[P], EnumsGroupByOutputType[P]>
+            : GetScalarType<T[P], EnumsGroupByOutputType[P]>
         }
       >
     >
 
 
-  export type TicketSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+  export type EnumsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
-    eventId?: boolean
-    type?: boolean
-    status?: boolean
-    fullName?: boolean
-    mail?: boolean
-    created_at?: boolean
-    updated_at?: boolean
-    event?: boolean | EventDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["ticket"]>
+    templateStatus?: boolean
+    templateCategory?: boolean
+  }, ExtArgs["result"]["enums"]>
 
-  export type TicketSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+  export type EnumsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
-    eventId?: boolean
-    type?: boolean
-    status?: boolean
-    fullName?: boolean
-    mail?: boolean
-    created_at?: boolean
-    updated_at?: boolean
-    event?: boolean | EventDefaultArgs<ExtArgs>
-  }, ExtArgs["result"]["ticket"]>
+    templateStatus?: boolean
+    templateCategory?: boolean
+  }, ExtArgs["result"]["enums"]>
 
-  export type TicketSelectScalar = {
+  export type EnumsSelectScalar = {
     id?: boolean
-    eventId?: boolean
-    type?: boolean
-    status?: boolean
-    fullName?: boolean
-    mail?: boolean
-    created_at?: boolean
-    updated_at?: boolean
+    templateStatus?: boolean
+    templateCategory?: boolean
   }
 
-  export type TicketInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    event?: boolean | EventDefaultArgs<ExtArgs>
-  }
-  export type TicketIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    event?: boolean | EventDefaultArgs<ExtArgs>
-  }
 
-  export type $TicketPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    name: "Ticket"
-    objects: {
-      event: Prisma.$EventPayload<ExtArgs>
-    }
+  export type $EnumsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "Enums"
+    objects: {}
     scalars: $Extensions.GetPayloadResult<{
       id: string
-      eventId: string
-      type: $Enums.TicketType
-      status: $Enums.TicketStatus
-      fullName: string
-      mail: string
-      created_at: Date
-      updated_at: Date
-    }, ExtArgs["result"]["ticket"]>
+      templateStatus: $Enums.TemplateStatus
+      templateCategory: $Enums.TemplateCategory
+    }, ExtArgs["result"]["enums"]>
     composites: {}
   }
 
-  type TicketGetPayload<S extends boolean | null | undefined | TicketDefaultArgs> = $Result.GetResult<Prisma.$TicketPayload, S>
+  type EnumsGetPayload<S extends boolean | null | undefined | EnumsDefaultArgs> = $Result.GetResult<Prisma.$EnumsPayload, S>
 
-  type TicketCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
-    Omit<TicketFindManyArgs, 'select' | 'include' | 'distinct'> & {
-      select?: TicketCountAggregateInputType | true
+  type EnumsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
+    Omit<EnumsFindManyArgs, 'select' | 'include' | 'distinct'> & {
+      select?: EnumsCountAggregateInputType | true
     }
 
-  export interface TicketDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
-    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Ticket'], meta: { name: 'Ticket' } }
+  export interface EnumsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Enums'], meta: { name: 'Enums' } }
     /**
-     * Find zero or one Ticket that matches the filter.
-     * @param {TicketFindUniqueArgs} args - Arguments to find a Ticket
+     * Find zero or one Enums that matches the filter.
+     * @param {EnumsFindUniqueArgs} args - Arguments to find a Enums
      * @example
-     * // Get one Ticket
-     * const ticket = await prisma.ticket.findUnique({
+     * // Get one Enums
+     * const enums = await prisma.enums.findUnique({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findUnique<T extends TicketFindUniqueArgs>(args: SelectSubset<T, TicketFindUniqueArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
+    findUnique<T extends EnumsFindUniqueArgs>(args: SelectSubset<T, EnumsFindUniqueArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
 
     /**
-     * Find one Ticket that matches the filter or throw an error with `error.code='P2025'` 
+     * Find one Enums that matches the filter or throw an error with `error.code='P2025'` 
      * if no matches were found.
-     * @param {TicketFindUniqueOrThrowArgs} args - Arguments to find a Ticket
+     * @param {EnumsFindUniqueOrThrowArgs} args - Arguments to find a Enums
      * @example
-     * // Get one Ticket
-     * const ticket = await prisma.ticket.findUniqueOrThrow({
+     * // Get one Enums
+     * const enums = await prisma.enums.findUniqueOrThrow({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findUniqueOrThrow<T extends TicketFindUniqueOrThrowArgs>(args: SelectSubset<T, TicketFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
+    findUniqueOrThrow<T extends EnumsFindUniqueOrThrowArgs>(args: SelectSubset<T, EnumsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
 
     /**
-     * Find the first Ticket that matches the filter.
+     * Find the first Enums 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 {TicketFindFirstArgs} args - Arguments to find a Ticket
+     * @param {EnumsFindFirstArgs} args - Arguments to find a Enums
      * @example
-     * // Get one Ticket
-     * const ticket = await prisma.ticket.findFirst({
+     * // Get one Enums
+     * const enums = await prisma.enums.findFirst({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findFirst<T extends TicketFindFirstArgs>(args?: SelectSubset<T, TicketFindFirstArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
+    findFirst<T extends EnumsFindFirstArgs>(args?: SelectSubset<T, EnumsFindFirstArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
 
     /**
-     * Find the first Ticket that matches the filter or
+     * Find the first Enums 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 {TicketFindFirstOrThrowArgs} args - Arguments to find a Ticket
+     * @param {EnumsFindFirstOrThrowArgs} args - Arguments to find a Enums
      * @example
-     * // Get one Ticket
-     * const ticket = await prisma.ticket.findFirstOrThrow({
+     * // Get one Enums
+     * const enums = await prisma.enums.findFirstOrThrow({
      *   where: {
      *     // ... provide filter here
      *   }
      * })
      */
-    findFirstOrThrow<T extends TicketFindFirstOrThrowArgs>(args?: SelectSubset<T, TicketFindFirstOrThrowArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
+    findFirstOrThrow<T extends EnumsFindFirstOrThrowArgs>(args?: SelectSubset<T, EnumsFindFirstOrThrowArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
 
     /**
-     * Find zero or more Tickets that matches the filter.
+     * Find zero or more Enums 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 {TicketFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @param {EnumsFindManyArgs} args - Arguments to filter and select certain fields only.
      * @example
-     * // Get all Tickets
-     * const tickets = await prisma.ticket.findMany()
+     * // Get all Enums
+     * const enums = await prisma.enums.findMany()
      * 
-     * // Get first 10 Tickets
-     * const tickets = await prisma.ticket.findMany({ take: 10 })
+     * // Get first 10 Enums
+     * const enums = await prisma.enums.findMany({ take: 10 })
      * 
      * // Only select the `id`
-     * const ticketWithIdOnly = await prisma.ticket.findMany({ select: { id: true } })
+     * const enumsWithIdOnly = await prisma.enums.findMany({ select: { id: true } })
      * 
      */
-    findMany<T extends TicketFindManyArgs>(args?: SelectSubset<T, TicketFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findMany">>
+    findMany<T extends EnumsFindManyArgs>(args?: SelectSubset<T, EnumsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findMany">>
 
     /**
-     * Create a Ticket.
-     * @param {TicketCreateArgs} args - Arguments to create a Ticket.
+     * Create a Enums.
+     * @param {EnumsCreateArgs} args - Arguments to create a Enums.
      * @example
-     * // Create one Ticket
-     * const Ticket = await prisma.ticket.create({
+     * // Create one Enums
+     * const Enums = await prisma.enums.create({
      *   data: {
-     *     // ... data to create a Ticket
+     *     // ... data to create a Enums
      *   }
      * })
      * 
      */
-    create<T extends TicketCreateArgs>(args: SelectSubset<T, TicketCreateArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "create">, never, ExtArgs>
+    create<T extends EnumsCreateArgs>(args: SelectSubset<T, EnumsCreateArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "create">, never, ExtArgs>
 
     /**
-     * Create many Tickets.
-     * @param {TicketCreateManyArgs} args - Arguments to create many Tickets.
+     * Create many Enums.
+     * @param {EnumsCreateManyArgs} args - Arguments to create many Enums.
      * @example
-     * // Create many Tickets
-     * const ticket = await prisma.ticket.createMany({
+     * // Create many Enums
+     * const enums = await prisma.enums.createMany({
      *   data: [
      *     // ... provide data here
      *   ]
      * })
      *     
      */
-    createMany<T extends TicketCreateManyArgs>(args?: SelectSubset<T, TicketCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+    createMany<T extends EnumsCreateManyArgs>(args?: SelectSubset<T, EnumsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
 
     /**
-     * Create many Tickets and returns the data saved in the database.
-     * @param {TicketCreateManyAndReturnArgs} args - Arguments to create many Tickets.
+     * Create many Enums and returns the data saved in the database.
+     * @param {EnumsCreateManyAndReturnArgs} args - Arguments to create many Enums.
      * @example
-     * // Create many Tickets
-     * const ticket = await prisma.ticket.createManyAndReturn({
+     * // Create many Enums
+     * const enums = await prisma.enums.createManyAndReturn({
      *   data: [
      *     // ... provide data here
      *   ]
      * })
      * 
-     * // Create many Tickets and only return the `id`
-     * const ticketWithIdOnly = await prisma.ticket.createManyAndReturn({ 
+     * // Create many Enums and only return the `id`
+     * const enumsWithIdOnly = await prisma.enums.createManyAndReturn({ 
      *   select: { id: true },
      *   data: [
      *     // ... provide data here
@@ -12802,911 +12593,7 @@ export namespace Prisma {
      * Read more here: https://pris.ly/d/null-undefined
      * 
      */
-    createManyAndReturn<T extends TicketCreateManyAndReturnArgs>(args?: SelectSubset<T, TicketCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "createManyAndReturn">>
-
-    /**
-     * Delete a Ticket.
-     * @param {TicketDeleteArgs} args - Arguments to delete one Ticket.
-     * @example
-     * // Delete one Ticket
-     * const Ticket = await prisma.ticket.delete({
-     *   where: {
-     *     // ... filter to delete one Ticket
-     *   }
-     * })
-     * 
-     */
-    delete<T extends TicketDeleteArgs>(args: SelectSubset<T, TicketDeleteArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "delete">, never, ExtArgs>
-
-    /**
-     * Update one Ticket.
-     * @param {TicketUpdateArgs} args - Arguments to update one Ticket.
-     * @example
-     * // Update one Ticket
-     * const ticket = await prisma.ticket.update({
-     *   where: {
-     *     // ... provide filter here
-     *   },
-     *   data: {
-     *     // ... provide data here
-     *   }
-     * })
-     * 
-     */
-    update<T extends TicketUpdateArgs>(args: SelectSubset<T, TicketUpdateArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "update">, never, ExtArgs>
-
-    /**
-     * Delete zero or more Tickets.
-     * @param {TicketDeleteManyArgs} args - Arguments to filter Tickets to delete.
-     * @example
-     * // Delete a few Tickets
-     * const { count } = await prisma.ticket.deleteMany({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     * 
-     */
-    deleteMany<T extends TicketDeleteManyArgs>(args?: SelectSubset<T, TicketDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
-
-    /**
-     * Update zero or more Tickets.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {TicketUpdateManyArgs} args - Arguments to update one or more rows.
-     * @example
-     * // Update many Tickets
-     * const ticket = await prisma.ticket.updateMany({
-     *   where: {
-     *     // ... provide filter here
-     *   },
-     *   data: {
-     *     // ... provide data here
-     *   }
-     * })
-     * 
-     */
-    updateMany<T extends TicketUpdateManyArgs>(args: SelectSubset<T, TicketUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
-
-    /**
-     * Create or update one Ticket.
-     * @param {TicketUpsertArgs} args - Arguments to update or create a Ticket.
-     * @example
-     * // Update or create a Ticket
-     * const ticket = await prisma.ticket.upsert({
-     *   create: {
-     *     // ... data to create a Ticket
-     *   },
-     *   update: {
-     *     // ... in case it already exists, update
-     *   },
-     *   where: {
-     *     // ... the filter for the Ticket we want to update
-     *   }
-     * })
-     */
-    upsert<T extends TicketUpsertArgs>(args: SelectSubset<T, TicketUpsertArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
-
-
-    /**
-     * Count the number of Tickets.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {TicketCountArgs} args - Arguments to filter Tickets to count.
-     * @example
-     * // Count the number of Tickets
-     * const count = await prisma.ticket.count({
-     *   where: {
-     *     // ... the filter for the Tickets we want to count
-     *   }
-     * })
-    **/
-    count<T extends TicketCountArgs>(
-      args?: Subset<T, TicketCountArgs>,
-    ): Prisma.PrismaPromise<
-      T extends $Utils.Record<'select', any>
-        ? T['select'] extends true
-          ? number
-          : GetScalarType<T['select'], TicketCountAggregateOutputType>
-        : number
-    >
-
-    /**
-     * Allows you to perform aggregations operations on a Ticket.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {TicketAggregateArgs} 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 TicketAggregateArgs>(args: Subset<T, TicketAggregateArgs>): Prisma.PrismaPromise<GetTicketAggregateType<T>>
-
-    /**
-     * Group by Ticket.
-     * Note, that providing `undefined` is treated as the value not being there.
-     * Read more here: https://pris.ly/d/null-undefined
-     * @param {TicketGroupByArgs} 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 TicketGroupByArgs,
-      HasSelectOrTake extends Or<
-        Extends<'skip', Keys<T>>,
-        Extends<'take', Keys<T>>
-      >,
-      OrderByArg extends True extends HasSelectOrTake
-        ? { orderBy: TicketGroupByArgs['orderBy'] }
-        : { orderBy?: TicketGroupByArgs['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, TicketGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTicketGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
-  /**
-   * Fields of the Ticket model
-   */
-  readonly fields: TicketFieldRefs;
-  }
-
-  /**
-   * The delegate class that acts as a "Promise-like" for Ticket.
-   * 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__TicketClient<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 Ticket model
-   */ 
-  interface TicketFieldRefs {
-    readonly id: FieldRef<"Ticket", 'String'>
-    readonly eventId: FieldRef<"Ticket", 'String'>
-    readonly type: FieldRef<"Ticket", 'TicketType'>
-    readonly status: FieldRef<"Ticket", 'TicketStatus'>
-    readonly fullName: FieldRef<"Ticket", 'String'>
-    readonly mail: FieldRef<"Ticket", 'String'>
-    readonly created_at: FieldRef<"Ticket", 'DateTime'>
-    readonly updated_at: FieldRef<"Ticket", 'DateTime'>
-  }
-    
-
-  // Custom InputTypes
-  /**
-   * Ticket findUnique
-   */
-  export type TicketFindUniqueArgs<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
-    /**
-     * Filter, which Ticket to fetch.
-     */
-    where: TicketWhereUniqueInput
-  }
-
-  /**
-   * Ticket findUniqueOrThrow
-   */
-  export type TicketFindUniqueOrThrowArgs<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
-    /**
-     * Filter, which Ticket to fetch.
-     */
-    where: TicketWhereUniqueInput
-  }
-
-  /**
-   * Ticket findFirst
-   */
-  export type TicketFindFirstArgs<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
-    /**
-     * Filter, which Ticket to fetch.
-     */
-    where?: TicketWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of Tickets to fetch.
-     */
-    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the position for searching for Tickets.
-     */
-    cursor?: TicketWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` Tickets 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` Tickets.
-     */
-    skip?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
-     * 
-     * Filter by unique combinations of Tickets.
-     */
-    distinct?: TicketScalarFieldEnum | TicketScalarFieldEnum[]
-  }
-
-  /**
-   * Ticket findFirstOrThrow
-   */
-  export type TicketFindFirstOrThrowArgs<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
-    /**
-     * Filter, which Ticket to fetch.
-     */
-    where?: TicketWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of Tickets to fetch.
-     */
-    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the position for searching for Tickets.
-     */
-    cursor?: TicketWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` Tickets 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` Tickets.
-     */
-    skip?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
-     * 
-     * Filter by unique combinations of Tickets.
-     */
-    distinct?: TicketScalarFieldEnum | TicketScalarFieldEnum[]
-  }
-
-  /**
-   * Ticket findMany
-   */
-  export type TicketFindManyArgs<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
-    /**
-     * Filter, which Tickets to fetch.
-     */
-    where?: TicketWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of Tickets to fetch.
-     */
-    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the position for listing Tickets.
-     */
-    cursor?: TicketWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` Tickets 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` Tickets.
-     */
-    skip?: number
-    distinct?: TicketScalarFieldEnum | TicketScalarFieldEnum[]
-  }
-
-  /**
-   * Ticket create
-   */
-  export type TicketCreateArgs<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
-    /**
-     * The data needed to create a Ticket.
-     */
-    data: XOR<TicketCreateInput, TicketUncheckedCreateInput>
-  }
-
-  /**
-   * Ticket createMany
-   */
-  export type TicketCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * The data used to create many Tickets.
-     */
-    data: TicketCreateManyInput | TicketCreateManyInput[]
-    skipDuplicates?: boolean
-  }
-
-  /**
-   * Ticket createManyAndReturn
-   */
-  export type TicketCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Select specific fields to fetch from the Ticket
-     */
-    select?: TicketSelectCreateManyAndReturn<ExtArgs> | null
-    /**
-     * The data used to create many Tickets.
-     */
-    data: TicketCreateManyInput | TicketCreateManyInput[]
-    skipDuplicates?: boolean
-    /**
-     * Choose, which related nodes to fetch as well
-     */
-    include?: TicketIncludeCreateManyAndReturn<ExtArgs> | null
-  }
-
-  /**
-   * Ticket update
-   */
-  export type TicketUpdateArgs<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
-    /**
-     * The data needed to update a Ticket.
-     */
-    data: XOR<TicketUpdateInput, TicketUncheckedUpdateInput>
-    /**
-     * Choose, which Ticket to update.
-     */
-    where: TicketWhereUniqueInput
-  }
-
-  /**
-   * Ticket updateMany
-   */
-  export type TicketUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * The data used to update Tickets.
-     */
-    data: XOR<TicketUpdateManyMutationInput, TicketUncheckedUpdateManyInput>
-    /**
-     * Filter which Tickets to update
-     */
-    where?: TicketWhereInput
-  }
-
-  /**
-   * Ticket upsert
-   */
-  export type TicketUpsertArgs<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
-    /**
-     * The filter to search for the Ticket to update in case it exists.
-     */
-    where: TicketWhereUniqueInput
-    /**
-     * In case the Ticket found by the `where` argument doesn't exist, create a new Ticket with this data.
-     */
-    create: XOR<TicketCreateInput, TicketUncheckedCreateInput>
-    /**
-     * In case the Ticket was found with the provided `where` argument, update it with this data.
-     */
-    update: XOR<TicketUpdateInput, TicketUncheckedUpdateInput>
-  }
-
-  /**
-   * Ticket delete
-   */
-  export type TicketDeleteArgs<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
-    /**
-     * Filter which Ticket to delete.
-     */
-    where: TicketWhereUniqueInput
-  }
-
-  /**
-   * Ticket deleteMany
-   */
-  export type TicketDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Filter which Tickets to delete
-     */
-    where?: TicketWhereInput
-  }
-
-  /**
-   * Ticket without action
-   */
-  export type TicketDefaultArgs<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
-  }
-
-
-  /**
-   * Model Enums
-   */
-
-  export type AggregateEnums = {
-    _count: EnumsCountAggregateOutputType | null
-    _min: EnumsMinAggregateOutputType | null
-    _max: EnumsMaxAggregateOutputType | null
-  }
-
-  export type EnumsMinAggregateOutputType = {
-    id: string | null
-    templateStatus: $Enums.TemplateStatus | null
-    templateCategory: $Enums.TemplateCategory | null
-  }
-
-  export type EnumsMaxAggregateOutputType = {
-    id: string | null
-    templateStatus: $Enums.TemplateStatus | null
-    templateCategory: $Enums.TemplateCategory | null
-  }
-
-  export type EnumsCountAggregateOutputType = {
-    id: number
-    templateStatus: number
-    templateCategory: number
-    _all: number
-  }
-
-
-  export type EnumsMinAggregateInputType = {
-    id?: true
-    templateStatus?: true
-    templateCategory?: true
-  }
-
-  export type EnumsMaxAggregateInputType = {
-    id?: true
-    templateStatus?: true
-    templateCategory?: true
-  }
-
-  export type EnumsCountAggregateInputType = {
-    id?: true
-    templateStatus?: true
-    templateCategory?: true
-    _all?: true
-  }
-
-  export type EnumsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    /**
-     * Filter which Enums to aggregate.
-     */
-    where?: EnumsWhereInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
-     * 
-     * Determine the order of Enums to fetch.
-     */
-    orderBy?: EnumsOrderByWithRelationInput | EnumsOrderByWithRelationInput[]
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
-     * 
-     * Sets the start position
-     */
-    cursor?: EnumsWhereUniqueInput
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
-     * 
-     * Take `±n` Enums 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` Enums.
-     */
-    skip?: number
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Count returned Enums
-    **/
-    _count?: true | EnumsCountAggregateInputType
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Select which fields to find the minimum value
-    **/
-    _min?: EnumsMinAggregateInputType
-    /**
-     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
-     * 
-     * Select which fields to find the maximum value
-    **/
-    _max?: EnumsMaxAggregateInputType
-  }
-
-  export type GetEnumsAggregateType<T extends EnumsAggregateArgs> = {
-        [P in keyof T & keyof AggregateEnums]: P extends '_count' | 'count'
-      ? T[P] extends true
-        ? number
-        : GetScalarType<T[P], AggregateEnums[P]>
-      : GetScalarType<T[P], AggregateEnums[P]>
-  }
-
-
-
-
-  export type EnumsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: EnumsWhereInput
-    orderBy?: EnumsOrderByWithAggregationInput | EnumsOrderByWithAggregationInput[]
-    by: EnumsScalarFieldEnum[] | EnumsScalarFieldEnum
-    having?: EnumsScalarWhereWithAggregatesInput
-    take?: number
-    skip?: number
-    _count?: EnumsCountAggregateInputType | true
-    _min?: EnumsMinAggregateInputType
-    _max?: EnumsMaxAggregateInputType
-  }
-
-  export type EnumsGroupByOutputType = {
-    id: string
-    templateStatus: $Enums.TemplateStatus
-    templateCategory: $Enums.TemplateCategory
-    _count: EnumsCountAggregateOutputType | null
-    _min: EnumsMinAggregateOutputType | null
-    _max: EnumsMaxAggregateOutputType | null
-  }
-
-  type GetEnumsGroupByPayload<T extends EnumsGroupByArgs> = Prisma.PrismaPromise<
-    Array<
-      PickEnumerable<EnumsGroupByOutputType, T['by']> &
-        {
-          [P in ((keyof T) & (keyof EnumsGroupByOutputType))]: P extends '_count'
-            ? T[P] extends boolean
-              ? number
-              : GetScalarType<T[P], EnumsGroupByOutputType[P]>
-            : GetScalarType<T[P], EnumsGroupByOutputType[P]>
-        }
-      >
-    >
-
-
-  export type EnumsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
-    id?: boolean
-    templateStatus?: boolean
-    templateCategory?: boolean
-  }, ExtArgs["result"]["enums"]>
-
-  export type EnumsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
-    id?: boolean
-    templateStatus?: boolean
-    templateCategory?: boolean
-  }, ExtArgs["result"]["enums"]>
-
-  export type EnumsSelectScalar = {
-    id?: boolean
-    templateStatus?: boolean
-    templateCategory?: boolean
-  }
-
-
-  export type $EnumsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    name: "Enums"
-    objects: {}
-    scalars: $Extensions.GetPayloadResult<{
-      id: string
-      templateStatus: $Enums.TemplateStatus
-      templateCategory: $Enums.TemplateCategory
-    }, ExtArgs["result"]["enums"]>
-    composites: {}
-  }
-
-  type EnumsGetPayload<S extends boolean | null | undefined | EnumsDefaultArgs> = $Result.GetResult<Prisma.$EnumsPayload, S>
-
-  type EnumsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
-    Omit<EnumsFindManyArgs, 'select' | 'include' | 'distinct'> & {
-      select?: EnumsCountAggregateInputType | true
-    }
-
-  export interface EnumsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
-    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Enums'], meta: { name: 'Enums' } }
-    /**
-     * Find zero or one Enums that matches the filter.
-     * @param {EnumsFindUniqueArgs} args - Arguments to find a Enums
-     * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findUnique({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findUnique<T extends EnumsFindUniqueArgs>(args: SelectSubset<T, EnumsFindUniqueArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
-
-    /**
-     * Find one Enums that matches the filter or throw an error with `error.code='P2025'` 
-     * if no matches were found.
-     * @param {EnumsFindUniqueOrThrowArgs} args - Arguments to find a Enums
-     * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findUniqueOrThrow({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findUniqueOrThrow<T extends EnumsFindUniqueOrThrowArgs>(args: SelectSubset<T, EnumsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
-
-    /**
-     * Find the first Enums 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 {EnumsFindFirstArgs} args - Arguments to find a Enums
-     * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findFirst({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findFirst<T extends EnumsFindFirstArgs>(args?: SelectSubset<T, EnumsFindFirstArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
-
-    /**
-     * Find the first Enums 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 {EnumsFindFirstOrThrowArgs} args - Arguments to find a Enums
-     * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findFirstOrThrow({
-     *   where: {
-     *     // ... provide filter here
-     *   }
-     * })
-     */
-    findFirstOrThrow<T extends EnumsFindFirstOrThrowArgs>(args?: SelectSubset<T, EnumsFindFirstOrThrowArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
-
-    /**
-     * Find zero or more Enums 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 {EnumsFindManyArgs} args - Arguments to filter and select certain fields only.
-     * @example
-     * // Get all Enums
-     * const enums = await prisma.enums.findMany()
-     * 
-     * // Get first 10 Enums
-     * const enums = await prisma.enums.findMany({ take: 10 })
-     * 
-     * // Only select the `id`
-     * const enumsWithIdOnly = await prisma.enums.findMany({ select: { id: true } })
-     * 
-     */
-    findMany<T extends EnumsFindManyArgs>(args?: SelectSubset<T, EnumsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findMany">>
-
-    /**
-     * Create a Enums.
-     * @param {EnumsCreateArgs} args - Arguments to create a Enums.
-     * @example
-     * // Create one Enums
-     * const Enums = await prisma.enums.create({
-     *   data: {
-     *     // ... data to create a Enums
-     *   }
-     * })
-     * 
-     */
-    create<T extends EnumsCreateArgs>(args: SelectSubset<T, EnumsCreateArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "create">, never, ExtArgs>
-
-    /**
-     * Create many Enums.
-     * @param {EnumsCreateManyArgs} args - Arguments to create many Enums.
-     * @example
-     * // Create many Enums
-     * const enums = await prisma.enums.createMany({
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     *     
-     */
-    createMany<T extends EnumsCreateManyArgs>(args?: SelectSubset<T, EnumsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
-
-    /**
-     * Create many Enums and returns the data saved in the database.
-     * @param {EnumsCreateManyAndReturnArgs} args - Arguments to create many Enums.
-     * @example
-     * // Create many Enums
-     * const enums = await prisma.enums.createManyAndReturn({
-     *   data: [
-     *     // ... provide data here
-     *   ]
-     * })
-     * 
-     * // Create many Enums and only return the `id`
-     * const enumsWithIdOnly = await prisma.enums.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 EnumsCreateManyAndReturnArgs>(args?: SelectSubset<T, EnumsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "createManyAndReturn">>
+    createManyAndReturn<T extends EnumsCreateManyAndReturnArgs>(args?: SelectSubset<T, EnumsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "createManyAndReturn">>
 
     /**
      * Delete a Enums.
@@ -14409,20 +13296,6 @@ export namespace Prisma {
   export type CannedResponseScalarFieldEnum = (typeof CannedResponseScalarFieldEnum)[keyof typeof CannedResponseScalarFieldEnum]
 
 
-  export const TicketScalarFieldEnum: {
-    id: 'id',
-    eventId: 'eventId',
-    type: 'type',
-    status: 'status',
-    fullName: 'fullName',
-    mail: 'mail',
-    created_at: 'created_at',
-    updated_at: 'updated_at'
-  };
-
-  export type TicketScalarFieldEnum = (typeof TicketScalarFieldEnum)[keyof typeof TicketScalarFieldEnum]
-
-
   export const EnumsScalarFieldEnum: {
     id: 'id',
     templateStatus: 'templateStatus',
@@ -14557,63 +13430,35 @@ export namespace Prisma {
   /**
    * Reference to a field of type 'TagType'
    */
-  export type EnumTagTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TagType'>
-    
-
-
-  /**
-   * Reference to a field of type 'TagType[]'
-   */
-  export type ListEnumTagTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TagType[]'>
-    
-
-
-  /**
-   * Reference to a field of type 'Json'
-   */
-  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
-    
-
-
-  /**
-   * Reference to a field of type 'MessageState'
-   */
-  export type EnumMessageStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageState'>
-    
-
-
-  /**
-   * Reference to a field of type 'MessageState[]'
-   */
-  export type ListEnumMessageStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageState[]'>
+  export type EnumTagTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TagType'>
     
 
 
   /**
-   * Reference to a field of type 'TicketType'
+   * Reference to a field of type 'TagType[]'
    */
-  export type EnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType'>
+  export type ListEnumTagTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TagType[]'>
     
 
 
   /**
-   * Reference to a field of type 'TicketType[]'
+   * Reference to a field of type 'Json'
    */
-  export type ListEnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType[]'>
+  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
     
 
 
   /**
-   * Reference to a field of type 'TicketStatus'
+   * Reference to a field of type 'MessageState'
    */
-  export type EnumTicketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketStatus'>
+  export type EnumMessageStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageState'>
     
 
 
   /**
-   * Reference to a field of type 'TicketStatus[]'
+   * Reference to a field of type 'MessageState[]'
    */
-  export type ListEnumTicketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketStatus[]'>
+  export type ListEnumMessageStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageState[]'>
     
 
 
@@ -15182,7 +14027,6 @@ export namespace Prisma {
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
     subEvents?: EventListRelationFilter
-    tickets?: TicketListRelationFilter
   }
 
   export type EventOrderByWithRelationInput = {
@@ -15201,7 +14045,6 @@ export namespace Prisma {
     tagConfirmed?: TagOrderByWithRelationInput
     supraEvent?: EventOrderByWithRelationInput
     subEvents?: EventOrderByRelationAggregateInput
-    tickets?: TicketOrderByRelationAggregateInput
   }
 
   export type EventWhereUniqueInput = Prisma.AtLeast<{
@@ -15223,7 +14066,6 @@ export namespace Prisma {
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
     subEvents?: EventListRelationFilter
-    tickets?: TicketListRelationFilter
   }, "id" | "tagAssistedId" | "tagConfirmedId">
 
   export type EventOrderByWithAggregationInput = {
@@ -15430,76 +14272,6 @@ export namespace Prisma {
     updated_at?: DateTimeWithAggregatesFilter<"CannedResponse"> | Date | string
   }
 
-  export type TicketWhereInput = {
-    AND?: TicketWhereInput | TicketWhereInput[]
-    OR?: TicketWhereInput[]
-    NOT?: TicketWhereInput | TicketWhereInput[]
-    id?: StringFilter<"Ticket"> | string
-    eventId?: StringFilter<"Ticket"> | string
-    type?: EnumTicketTypeFilter<"Ticket"> | $Enums.TicketType
-    status?: EnumTicketStatusFilter<"Ticket"> | $Enums.TicketStatus
-    fullName?: StringFilter<"Ticket"> | string
-    mail?: StringFilter<"Ticket"> | string
-    created_at?: DateTimeFilter<"Ticket"> | Date | string
-    updated_at?: DateTimeFilter<"Ticket"> | Date | string
-    event?: XOR<EventRelationFilter, EventWhereInput>
-  }
-
-  export type TicketOrderByWithRelationInput = {
-    id?: SortOrder
-    eventId?: SortOrder
-    type?: SortOrder
-    status?: SortOrder
-    fullName?: SortOrder
-    mail?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-    event?: EventOrderByWithRelationInput
-  }
-
-  export type TicketWhereUniqueInput = Prisma.AtLeast<{
-    id?: string
-    AND?: TicketWhereInput | TicketWhereInput[]
-    OR?: TicketWhereInput[]
-    NOT?: TicketWhereInput | TicketWhereInput[]
-    eventId?: StringFilter<"Ticket"> | string
-    type?: EnumTicketTypeFilter<"Ticket"> | $Enums.TicketType
-    status?: EnumTicketStatusFilter<"Ticket"> | $Enums.TicketStatus
-    fullName?: StringFilter<"Ticket"> | string
-    mail?: StringFilter<"Ticket"> | string
-    created_at?: DateTimeFilter<"Ticket"> | Date | string
-    updated_at?: DateTimeFilter<"Ticket"> | Date | string
-    event?: XOR<EventRelationFilter, EventWhereInput>
-  }, "id">
-
-  export type TicketOrderByWithAggregationInput = {
-    id?: SortOrder
-    eventId?: SortOrder
-    type?: SortOrder
-    status?: SortOrder
-    fullName?: SortOrder
-    mail?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-    _count?: TicketCountOrderByAggregateInput
-    _max?: TicketMaxOrderByAggregateInput
-    _min?: TicketMinOrderByAggregateInput
-  }
-
-  export type TicketScalarWhereWithAggregatesInput = {
-    AND?: TicketScalarWhereWithAggregatesInput | TicketScalarWhereWithAggregatesInput[]
-    OR?: TicketScalarWhereWithAggregatesInput[]
-    NOT?: TicketScalarWhereWithAggregatesInput | TicketScalarWhereWithAggregatesInput[]
-    id?: StringWithAggregatesFilter<"Ticket"> | string
-    eventId?: StringWithAggregatesFilter<"Ticket"> | string
-    type?: EnumTicketTypeWithAggregatesFilter<"Ticket"> | $Enums.TicketType
-    status?: EnumTicketStatusWithAggregatesFilter<"Ticket"> | $Enums.TicketStatus
-    fullName?: StringWithAggregatesFilter<"Ticket"> | string
-    mail?: StringWithAggregatesFilter<"Ticket"> | string
-    created_at?: DateTimeWithAggregatesFilter<"Ticket"> | Date | string
-    updated_at?: DateTimeWithAggregatesFilter<"Ticket"> | Date | string
-  }
-
   export type EnumsWhereInput = {
     AND?: EnumsWhereInput | EnumsWhereInput[]
     OR?: EnumsWhereInput[]
@@ -16133,7 +14905,6 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateInput = {
@@ -16148,7 +14919,6 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventUpdateInput = {
@@ -16163,7 +14933,6 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateInput = {
@@ -16178,7 +14947,6 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventCreateManyInput = {
@@ -16401,82 +15169,6 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
-  export type TicketCreateInput = {
-    id?: string
-    type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
-    created_at?: Date | string
-    updated_at?: Date | string
-    event: EventCreateNestedOneWithoutTicketsInput
-  }
-
-  export type TicketUncheckedCreateInput = {
-    id?: string
-    eventId: string
-    type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
-    created_at?: Date | string
-    updated_at?: Date | string
-  }
-
-  export type TicketUpdateInput = {
-    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
-    event?: EventUpdateOneRequiredWithoutTicketsNestedInput
-  }
-
-  export type TicketUncheckedUpdateInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    eventId?: 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 TicketCreateManyInput = {
-    id?: string
-    eventId: string
-    type: $Enums.TicketType
-    status: $Enums.TicketStatus
-    fullName: string
-    mail: string
-    created_at?: Date | string
-    updated_at?: Date | string
-  }
-
-  export type TicketUpdateManyMutationInput = {
-    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 TicketUncheckedUpdateManyInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    eventId?: 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 EnumsCreateInput = {
     id: string
     templateStatus: $Enums.TemplateStatus
@@ -17089,20 +15781,10 @@ export namespace Prisma {
     none?: EventWhereInput
   }
 
-  export type TicketListRelationFilter = {
-    every?: TicketWhereInput
-    some?: TicketWhereInput
-    none?: TicketWhereInput
-  }
-
   export type EventOrderByRelationAggregateInput = {
     _count?: SortOrder
   }
 
-  export type TicketOrderByRelationAggregateInput = {
-    _count?: SortOrder
-  }
-
   export type EventCountOrderByAggregateInput = {
     id?: SortOrder
     name?: SortOrder
@@ -17282,78 +15964,6 @@ export namespace Prisma {
     updated_at?: SortOrder
   }
 
-  export type EnumTicketTypeFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketType | EnumTicketTypeFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketTypeFilter<$PrismaModel> | $Enums.TicketType
-  }
-
-  export type EnumTicketStatusFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketStatus | EnumTicketStatusFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketStatusFilter<$PrismaModel> | $Enums.TicketStatus
-  }
-
-  export type EventRelationFilter = {
-    is?: EventWhereInput
-    isNot?: EventWhereInput
-  }
-
-  export type TicketCountOrderByAggregateInput = {
-    id?: SortOrder
-    eventId?: SortOrder
-    type?: SortOrder
-    status?: SortOrder
-    fullName?: SortOrder
-    mail?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-  }
-
-  export type TicketMaxOrderByAggregateInput = {
-    id?: SortOrder
-    eventId?: SortOrder
-    type?: SortOrder
-    status?: SortOrder
-    fullName?: SortOrder
-    mail?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-  }
-
-  export type TicketMinOrderByAggregateInput = {
-    id?: SortOrder
-    eventId?: SortOrder
-    type?: SortOrder
-    status?: SortOrder
-    fullName?: SortOrder
-    mail?: SortOrder
-    created_at?: SortOrder
-    updated_at?: SortOrder
-  }
-
-  export type EnumTicketTypeWithAggregatesFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketType | EnumTicketTypeFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketTypeWithAggregatesFilter<$PrismaModel> | $Enums.TicketType
-    _count?: NestedIntFilter<$PrismaModel>
-    _min?: NestedEnumTicketTypeFilter<$PrismaModel>
-    _max?: NestedEnumTicketTypeFilter<$PrismaModel>
-  }
-
-  export type EnumTicketStatusWithAggregatesFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketStatus | EnumTicketStatusFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketStatusWithAggregatesFilter<$PrismaModel> | $Enums.TicketStatus
-    _count?: NestedIntFilter<$PrismaModel>
-    _min?: NestedEnumTicketStatusFilter<$PrismaModel>
-    _max?: NestedEnumTicketStatusFilter<$PrismaModel>
-  }
-
   export type EnumTemplateStatusFilter<$PrismaModel = never> = {
     equals?: $Enums.TemplateStatus | EnumTemplateStatusFieldRefInput<$PrismaModel>
     in?: $Enums.TemplateStatus[] | ListEnumTemplateStatusFieldRefInput<$PrismaModel>
@@ -18175,13 +16785,6 @@ export namespace Prisma {
     connect?: EventWhereUniqueInput | EventWhereUniqueInput[]
   }
 
-  export type TicketCreateNestedManyWithoutEventInput = {
-    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
-    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
-    createMany?: TicketCreateManyEventInputEnvelope
-    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
-  }
-
   export type EventUncheckedCreateNestedManyWithoutSupraEventInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18189,13 +16792,6 @@ 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 EventFolderUpdateOneWithoutEventsNestedInput = {
     create?: XOR<EventFolderCreateWithoutEventsInput, EventFolderUncheckedCreateWithoutEventsInput>
     connectOrCreate?: EventFolderCreateOrConnectWithoutEventsInput
@@ -18246,20 +16842,6 @@ export namespace Prisma {
     deleteMany?: EventScalarWhereInput | EventScalarWhereInput[]
   }
 
-  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 EventUncheckedUpdateManyWithoutSupraEventNestedInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18274,20 +16856,6 @@ 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 EventCreateNestedManyWithoutFolderInput = {
     create?: XOR<EventCreateWithoutFolderInput, EventUncheckedCreateWithoutFolderInput> | EventCreateWithoutFolderInput[] | EventUncheckedCreateWithoutFolderInput[]
     connectOrCreate?: EventCreateOrConnectWithoutFolderInput | EventCreateOrConnectWithoutFolderInput[]
@@ -18348,28 +16916,6 @@ export namespace Prisma {
     update?: XOR<XOR<ProfileUpdateToOneWithWhereWithoutMessagesInput, ProfileUpdateWithoutMessagesInput>, ProfileUncheckedUpdateWithoutMessagesInput>
   }
 
-  export type EventCreateNestedOneWithoutTicketsInput = {
-    create?: XOR<EventCreateWithoutTicketsInput, EventUncheckedCreateWithoutTicketsInput>
-    connectOrCreate?: EventCreateOrConnectWithoutTicketsInput
-    connect?: EventWhereUniqueInput
-  }
-
-  export type EnumTicketTypeFieldUpdateOperationsInput = {
-    set?: $Enums.TicketType
-  }
-
-  export type EnumTicketStatusFieldUpdateOperationsInput = {
-    set?: $Enums.TicketStatus
-  }
-
-  export type EventUpdateOneRequiredWithoutTicketsNestedInput = {
-    create?: XOR<EventCreateWithoutTicketsInput, EventUncheckedCreateWithoutTicketsInput>
-    connectOrCreate?: EventCreateOrConnectWithoutTicketsInput
-    upsert?: EventUpsertWithoutTicketsInput
-    connect?: EventWhereUniqueInput
-    update?: XOR<XOR<EventUpdateToOneWithWhereWithoutTicketsInput, EventUpdateWithoutTicketsInput>, EventUncheckedUpdateWithoutTicketsInput>
-  }
-
   export type EnumTemplateStatusFieldUpdateOperationsInput = {
     set?: $Enums.TemplateStatus
   }
@@ -18641,40 +17187,6 @@ export namespace Prisma {
     _max?: NestedEnumMessageStateFilter<$PrismaModel>
   }
 
-  export type NestedEnumTicketTypeFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketType | EnumTicketTypeFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketTypeFilter<$PrismaModel> | $Enums.TicketType
-  }
-
-  export type NestedEnumTicketStatusFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketStatus | EnumTicketStatusFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketStatusFilter<$PrismaModel> | $Enums.TicketStatus
-  }
-
-  export type NestedEnumTicketTypeWithAggregatesFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketType | EnumTicketTypeFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketType[] | ListEnumTicketTypeFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketTypeWithAggregatesFilter<$PrismaModel> | $Enums.TicketType
-    _count?: NestedIntFilter<$PrismaModel>
-    _min?: NestedEnumTicketTypeFilter<$PrismaModel>
-    _max?: NestedEnumTicketTypeFilter<$PrismaModel>
-  }
-
-  export type NestedEnumTicketStatusWithAggregatesFilter<$PrismaModel = never> = {
-    equals?: $Enums.TicketStatus | EnumTicketStatusFieldRefInput<$PrismaModel>
-    in?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    notIn?: $Enums.TicketStatus[] | ListEnumTicketStatusFieldRefInput<$PrismaModel>
-    not?: NestedEnumTicketStatusWithAggregatesFilter<$PrismaModel> | $Enums.TicketStatus
-    _count?: NestedIntFilter<$PrismaModel>
-    _min?: NestedEnumTicketStatusFilter<$PrismaModel>
-    _max?: NestedEnumTicketStatusFilter<$PrismaModel>
-  }
-
   export type NestedEnumTemplateStatusFilter<$PrismaModel = never> = {
     equals?: $Enums.TemplateStatus | EnumTemplateStatusFieldRefInput<$PrismaModel>
     in?: $Enums.TemplateStatus[] | ListEnumTemplateStatusFieldRefInput<$PrismaModel>
@@ -19676,7 +18188,6 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTagAssistedInput = {
@@ -19690,7 +18201,6 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTagAssistedInput = {
@@ -19709,7 +18219,6 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTagConfirmedInput = {
@@ -19723,7 +18232,6 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTagConfirmedInput = {
@@ -19901,7 +18409,6 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTagAssistedInput = {
@@ -19915,7 +18422,6 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUpsertWithoutTagConfirmedInput = {
@@ -19940,7 +18446,6 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTagConfirmedInput = {
@@ -19954,7 +18459,6 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type AccountUpsertWithWhereUniqueWithoutTagsInput = {
@@ -20165,7 +18669,6 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
-    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutSubEventsInput = {
@@ -20179,7 +18682,6 @@ export namespace Prisma {
     supraEventId?: string | null
     created_at?: Date | string
     updated_at?: Date | string
-    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutSubEventsInput = {
@@ -20198,7 +18700,6 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutSupraEventInput = {
@@ -20212,7 +18713,6 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutSupraEventInput = {
@@ -20225,36 +18725,6 @@ export namespace Prisma {
     skipDuplicates?: boolean
   }
 
-  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 EventFolderUpsertWithoutEventsInput = {
     update: XOR<EventFolderUpdateWithoutEventsInput, EventFolderUncheckedUpdateWithoutEventsInput>
     create: XOR<EventFolderCreateWithoutEventsInput, EventFolderUncheckedCreateWithoutEventsInput>
@@ -20378,7 +18848,6 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
-    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutSubEventsInput = {
@@ -20392,7 +18861,6 @@ export namespace Prisma {
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUpsertWithWhereUniqueWithoutSupraEventInput = {
@@ -20427,36 +18895,6 @@ export namespace Prisma {
     updated_at?: DateTimeFilter<"Event"> | Date | string
   }
 
-  export type TicketUpsertWithWhereUniqueWithoutEventInput = {
-    where: TicketWhereUniqueInput
-    update: XOR<TicketUpdateWithoutEventInput, TicketUncheckedUpdateWithoutEventInput>
-    create: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput>
-  }
-
-  export type TicketUpdateWithWhereUniqueWithoutEventInput = {
-    where: TicketWhereUniqueInput
-    data: XOR<TicketUpdateWithoutEventInput, TicketUncheckedUpdateWithoutEventInput>
-  }
-
-  export type TicketUpdateManyWithWhereWithoutEventInput = {
-    where: TicketScalarWhereInput
-    data: XOR<TicketUpdateManyMutationInput, TicketUncheckedUpdateManyWithoutEventInput>
-  }
-
-  export type TicketScalarWhereInput = {
-    AND?: TicketScalarWhereInput | TicketScalarWhereInput[]
-    OR?: TicketScalarWhereInput[]
-    NOT?: TicketScalarWhereInput | TicketScalarWhereInput[]
-    id?: StringFilter<"Ticket"> | string
-    eventId?: StringFilter<"Ticket"> | string
-    type?: EnumTicketTypeFilter<"Ticket"> | $Enums.TicketType
-    status?: EnumTicketStatusFilter<"Ticket"> | $Enums.TicketStatus
-    fullName?: StringFilter<"Ticket"> | string
-    mail?: StringFilter<"Ticket"> | string
-    created_at?: DateTimeFilter<"Ticket"> | Date | string
-    updated_at?: DateTimeFilter<"Ticket"> | Date | string
-  }
-
   export type EventCreateWithoutFolderInput = {
     id?: string
     name: string
@@ -20468,7 +18906,6 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutFolderInput = {
@@ -20482,7 +18919,6 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
-    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutFolderInput = {
@@ -20623,78 +19059,6 @@ export namespace Prisma {
     tags?: TagUncheckedUpdateManyWithoutProfilesNestedInput
   }
 
-  export type EventCreateWithoutTicketsInput = {
-    id?: string
-    name: string
-    date: Date | string
-    location: string
-    created_at?: Date | string
-    updated_at?: Date | string
-    folder?: EventFolderCreateNestedOneWithoutEventsInput
-    tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
-    tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
-    supraEvent?: EventCreateNestedOneWithoutSubEventsInput
-    subEvents?: EventCreateNestedManyWithoutSupraEventInput
-  }
-
-  export type EventUncheckedCreateWithoutTicketsInput = {
-    id?: string
-    name: string
-    date: Date | string
-    location: string
-    folderId?: string | null
-    tagAssistedId: string
-    tagConfirmedId: string
-    supraEventId?: string | null
-    created_at?: Date | string
-    updated_at?: Date | string
-    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
-  }
-
-  export type EventCreateOrConnectWithoutTicketsInput = {
-    where: EventWhereUniqueInput
-    create: XOR<EventCreateWithoutTicketsInput, EventUncheckedCreateWithoutTicketsInput>
-  }
-
-  export type EventUpsertWithoutTicketsInput = {
-    update: XOR<EventUpdateWithoutTicketsInput, EventUncheckedUpdateWithoutTicketsInput>
-    create: XOR<EventCreateWithoutTicketsInput, EventUncheckedCreateWithoutTicketsInput>
-    where?: EventWhereInput
-  }
-
-  export type EventUpdateToOneWithWhereWithoutTicketsInput = {
-    where?: EventWhereInput
-    data: XOR<EventUpdateWithoutTicketsInput, EventUncheckedUpdateWithoutTicketsInput>
-  }
-
-  export type EventUpdateWithoutTicketsInput = {
-    id?: StringFieldUpdateOperationsInput | string
-    name?: StringFieldUpdateOperationsInput | string
-    date?: DateTimeFieldUpdateOperationsInput | Date | string
-    location?: StringFieldUpdateOperationsInput | string
-    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
-    folder?: EventFolderUpdateOneWithoutEventsNestedInput
-    tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
-    tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
-    supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
-    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
-  }
-
-  export type EventUncheckedUpdateWithoutTicketsInput = {
-    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
-    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
-  }
-
   export type CommentCreateManyAccountInput = {
     id?: string
     content: string
@@ -21362,16 +19726,6 @@ export namespace Prisma {
     updated_at?: 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 EventUpdateWithoutSupraEventInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
@@ -21383,7 +19737,6 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutSupraEventInput = {
@@ -21397,7 +19750,6 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateManyWithoutSupraEventInput = {
@@ -21412,36 +19764,6 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | 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 EventCreateManyFolderInput = {
     id?: string
     name: string
@@ -21465,7 +19787,6 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutFolderInput = {
@@ -21479,7 +19800,6 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
-    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateManyWithoutFolderInput = {
@@ -21567,10 +19887,6 @@ export namespace Prisma {
      * @deprecated Use CannedResponseDefaultArgs instead
      */
     export type CannedResponseArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CannedResponseDefaultArgs<ExtArgs>
-    /**
-     * @deprecated Use TicketDefaultArgs instead
-     */
-    export type TicketArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TicketDefaultArgs<ExtArgs>
     /**
      * @deprecated Use EnumsDefaultArgs instead
      */