expo-backend-types 0.31.0-EXPO-315-Marcelo-Tinelli.1 → 0.31.0-EXPO-316-EB-Modificar-DB-Schema-Tickets.2

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

@@ -63,6 +63,11 @@ 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
  * 
@@ -101,6 +106,23 @@ 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',
@@ -132,6 +154,14 @@ 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
@@ -363,6 +393,16 @@ 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:
@@ -823,6 +863,7 @@ export namespace Prisma {
     EventFolder: 'EventFolder',
     Message: 'Message',
     CannedResponse: 'CannedResponse',
+    Ticket: 'Ticket',
     Enums: 'Enums'
   };
 
@@ -839,7 +880,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" | "enums"
+      modelProps: "account" | "profile" | "location" | "comment" | "tag" | "tagGroup" | "event" | "eventFolder" | "message" | "cannedResponse" | "ticket" | "enums"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -1543,6 +1584,76 @@ 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
@@ -2002,10 +2113,12 @@ 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
@@ -2026,6 +2139,13 @@ export namespace Prisma {
     where?: EventWhereInput
   }
 
+  /**
+   * EventCountOutputType without action
+   */
+  export type EventCountOutputTypeCountTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: TicketWhereInput
+  }
+
 
   /**
    * Count Type EventFolderCountOutputType
@@ -8647,6 +8767,7 @@ 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"]>
 
@@ -8686,6 +8807,7 @@ 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> = {
@@ -8703,6 +8825,7 @@ 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
@@ -9084,6 +9207,7 @@ 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.
@@ -9490,6 +9614,26 @@ 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
    */
@@ -12285,305 +12429,370 @@ export namespace Prisma {
 
 
   /**
-   * Model Enums
+   * Model Ticket
    */
 
-  export type AggregateEnums = {
-    _count: EnumsCountAggregateOutputType | null
-    _min: EnumsMinAggregateOutputType | null
-    _max: EnumsMaxAggregateOutputType | null
+  export type AggregateTicket = {
+    _count: TicketCountAggregateOutputType | null
+    _min: TicketMinAggregateOutputType | null
+    _max: TicketMaxAggregateOutputType | null
   }
 
-  export type EnumsMinAggregateOutputType = {
+  export type TicketMinAggregateOutputType = {
     id: string | null
-    templateStatus: $Enums.TemplateStatus | null
-    templateCategory: $Enums.TemplateCategory | 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
   }
 
-  export type EnumsMaxAggregateOutputType = {
+  export type TicketMaxAggregateOutputType = {
     id: string | null
-    templateStatus: $Enums.TemplateStatus | null
-    templateCategory: $Enums.TemplateCategory | 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
   }
 
-  export type EnumsCountAggregateOutputType = {
+  export type TicketCountAggregateOutputType = {
     id: number
-    templateStatus: number
-    templateCategory: number
+    eventId: number
+    type: number
+    status: number
+    fullName: number
+    mail: number
+    created_at: number
+    updated_at: number
     _all: number
   }
 
 
-  export type EnumsMinAggregateInputType = {
+  export type TicketMinAggregateInputType = {
     id?: true
-    templateStatus?: true
-    templateCategory?: true
+    eventId?: true
+    type?: true
+    status?: true
+    fullName?: true
+    mail?: true
+    created_at?: true
+    updated_at?: true
   }
 
-  export type EnumsMaxAggregateInputType = {
+  export type TicketMaxAggregateInputType = {
     id?: true
-    templateStatus?: true
-    templateCategory?: true
+    eventId?: true
+    type?: true
+    status?: true
+    fullName?: true
+    mail?: true
+    created_at?: true
+    updated_at?: true
   }
 
-  export type EnumsCountAggregateInputType = {
+  export type TicketCountAggregateInputType = {
     id?: true
-    templateStatus?: true
-    templateCategory?: true
+    eventId?: true
+    type?: true
+    status?: true
+    fullName?: true
+    mail?: true
+    created_at?: true
+    updated_at?: true
     _all?: true
   }
 
-  export type EnumsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type TicketAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Filter which Enums to aggregate.
+     * Filter which Ticket to aggregate.
      */
-    where?: EnumsWhereInput
+    where?: TicketWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of Enums to fetch.
+     * Determine the order of Tickets to fetch.
      */
-    orderBy?: EnumsOrderByWithRelationInput | EnumsOrderByWithRelationInput[]
+    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
      * Sets the start position
      */
-    cursor?: EnumsWhereUniqueInput
+    cursor?: TicketWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` Enums from the position of the cursor.
+     * 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` Enums.
+     * Skip the first `n` Tickets.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
-     * Count returned Enums
+     * Count returned Tickets
     **/
-    _count?: true | EnumsCountAggregateInputType
+    _count?: true | TicketCountAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the minimum value
     **/
-    _min?: EnumsMinAggregateInputType
+    _min?: TicketMinAggregateInputType
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
      * 
      * Select which fields to find the maximum value
     **/
-    _max?: EnumsMaxAggregateInputType
+    _max?: TicketMaxAggregateInputType
   }
 
-  export type GetEnumsAggregateType<T extends EnumsAggregateArgs> = {
-        [P in keyof T & keyof AggregateEnums]: P extends '_count' | 'count'
+  export type GetTicketAggregateType<T extends TicketAggregateArgs> = {
+        [P in keyof T & keyof AggregateTicket]: P extends '_count' | 'count'
       ? T[P] extends true
         ? number
-        : GetScalarType<T[P], AggregateEnums[P]>
-      : GetScalarType<T[P], AggregateEnums[P]>
+        : GetScalarType<T[P], AggregateTicket[P]>
+      : GetScalarType<T[P], AggregateTicket[P]>
   }
 
 
 
 
-  export type EnumsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    where?: EnumsWhereInput
-    orderBy?: EnumsOrderByWithAggregationInput | EnumsOrderByWithAggregationInput[]
-    by: EnumsScalarFieldEnum[] | EnumsScalarFieldEnum
-    having?: EnumsScalarWhereWithAggregatesInput
+  export type TicketGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: TicketWhereInput
+    orderBy?: TicketOrderByWithAggregationInput | TicketOrderByWithAggregationInput[]
+    by: TicketScalarFieldEnum[] | TicketScalarFieldEnum
+    having?: TicketScalarWhereWithAggregatesInput
     take?: number
     skip?: number
-    _count?: EnumsCountAggregateInputType | true
-    _min?: EnumsMinAggregateInputType
-    _max?: EnumsMaxAggregateInputType
+    _count?: TicketCountAggregateInputType | true
+    _min?: TicketMinAggregateInputType
+    _max?: TicketMaxAggregateInputType
   }
 
-  export type EnumsGroupByOutputType = {
+  export type TicketGroupByOutputType = {
     id: string
-    templateStatus: $Enums.TemplateStatus
-    templateCategory: $Enums.TemplateCategory
-    _count: EnumsCountAggregateOutputType | null
-    _min: EnumsMinAggregateOutputType | null
-    _max: EnumsMaxAggregateOutputType | null
+    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
   }
 
-  type GetEnumsGroupByPayload<T extends EnumsGroupByArgs> = Prisma.PrismaPromise<
+  type GetTicketGroupByPayload<T extends TicketGroupByArgs> = Prisma.PrismaPromise<
     Array<
-      PickEnumerable<EnumsGroupByOutputType, T['by']> &
+      PickEnumerable<TicketGroupByOutputType, T['by']> &
         {
-          [P in ((keyof T) & (keyof EnumsGroupByOutputType))]: P extends '_count'
+          [P in ((keyof T) & (keyof TicketGroupByOutputType))]: P extends '_count'
             ? T[P] extends boolean
               ? number
-              : GetScalarType<T[P], EnumsGroupByOutputType[P]>
-            : GetScalarType<T[P], EnumsGroupByOutputType[P]>
+              : GetScalarType<T[P], TicketGroupByOutputType[P]>
+            : GetScalarType<T[P], TicketGroupByOutputType[P]>
         }
       >
     >
 
 
-  export type EnumsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+  export type TicketSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
-    templateStatus?: boolean
-    templateCategory?: boolean
-  }, ExtArgs["result"]["enums"]>
+    eventId?: boolean
+    type?: boolean
+    status?: boolean
+    fullName?: boolean
+    mail?: boolean
+    created_at?: boolean
+    updated_at?: boolean
+    event?: boolean | EventDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["ticket"]>
 
-  export type EnumsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+  export type TicketSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
     id?: boolean
-    templateStatus?: boolean
-    templateCategory?: boolean
-  }, ExtArgs["result"]["enums"]>
+    eventId?: boolean
+    type?: boolean
+    status?: boolean
+    fullName?: boolean
+    mail?: boolean
+    created_at?: boolean
+    updated_at?: boolean
+    event?: boolean | EventDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["ticket"]>
 
-  export type EnumsSelectScalar = {
+  export type TicketSelectScalar = {
     id?: boolean
-    templateStatus?: boolean
-    templateCategory?: boolean
+    eventId?: boolean
+    type?: boolean
+    status?: boolean
+    fullName?: boolean
+    mail?: boolean
+    created_at?: boolean
+    updated_at?: 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 $EnumsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-    name: "Enums"
-    objects: {}
+  export type $TicketPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "Ticket"
+    objects: {
+      event: Prisma.$EventPayload<ExtArgs>
+    }
     scalars: $Extensions.GetPayloadResult<{
       id: string
-      templateStatus: $Enums.TemplateStatus
-      templateCategory: $Enums.TemplateCategory
-    }, ExtArgs["result"]["enums"]>
+      eventId: string
+      type: $Enums.TicketType
+      status: $Enums.TicketStatus
+      fullName: string
+      mail: string
+      created_at: Date
+      updated_at: Date
+    }, ExtArgs["result"]["ticket"]>
     composites: {}
   }
 
-  type EnumsGetPayload<S extends boolean | null | undefined | EnumsDefaultArgs> = $Result.GetResult<Prisma.$EnumsPayload, S>
+  type TicketGetPayload<S extends boolean | null | undefined | TicketDefaultArgs> = $Result.GetResult<Prisma.$TicketPayload, S>
 
-  type EnumsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
-    Omit<EnumsFindManyArgs, 'select' | 'include' | 'distinct'> & {
-      select?: EnumsCountAggregateInputType | true
+  type TicketCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
+    Omit<TicketFindManyArgs, 'select' | 'include' | 'distinct'> & {
+      select?: TicketCountAggregateInputType | true
     }
 
-  export interface EnumsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
-    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Enums'], meta: { name: 'Enums' } }
+  export interface TicketDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Ticket'], meta: { name: 'Ticket' } }
     /**
-     * Find zero or one Enums that matches the filter.
-     * @param {EnumsFindUniqueArgs} args - Arguments to find a Enums
+     * Find zero or one Ticket that matches the filter.
+     * @param {TicketFindUniqueArgs} args - Arguments to find a Ticket
      * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findUnique({
+     * // Get one Ticket
+     * const ticket = await prisma.ticket.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>
+    findUnique<T extends TicketFindUniqueArgs>(args: SelectSubset<T, TicketFindUniqueArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
 
     /**
-     * Find one Enums that matches the filter or throw an error with `error.code='P2025'` 
+     * Find one Ticket 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
+     * @param {TicketFindUniqueOrThrowArgs} args - Arguments to find a Ticket
      * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findUniqueOrThrow({
+     * // Get one Ticket
+     * const ticket = await prisma.ticket.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>
+    findUniqueOrThrow<T extends TicketFindUniqueOrThrowArgs>(args: SelectSubset<T, TicketFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
 
     /**
-     * Find the first Enums that matches the filter.
+     * Find the first Ticket 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
+     * @param {TicketFindFirstArgs} args - Arguments to find a Ticket
      * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findFirst({
+     * // Get one Ticket
+     * const ticket = await prisma.ticket.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>
+    findFirst<T extends TicketFindFirstArgs>(args?: SelectSubset<T, TicketFindFirstArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
 
     /**
-     * Find the first Enums that matches the filter or
+     * Find the first Ticket 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
+     * @param {TicketFindFirstOrThrowArgs} args - Arguments to find a Ticket
      * @example
-     * // Get one Enums
-     * const enums = await prisma.enums.findFirstOrThrow({
+     * // Get one Ticket
+     * const ticket = await prisma.ticket.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>
+    findFirstOrThrow<T extends TicketFindFirstOrThrowArgs>(args?: SelectSubset<T, TicketFindFirstOrThrowArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
 
     /**
-     * Find zero or more Enums that matches the filter.
+     * Find zero or more Tickets 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.
+     * @param {TicketFindManyArgs} args - Arguments to filter and select certain fields only.
      * @example
-     * // Get all Enums
-     * const enums = await prisma.enums.findMany()
+     * // Get all Tickets
+     * const tickets = await prisma.ticket.findMany()
      * 
-     * // Get first 10 Enums
-     * const enums = await prisma.enums.findMany({ take: 10 })
+     * // Get first 10 Tickets
+     * const tickets = await prisma.ticket.findMany({ take: 10 })
      * 
      * // Only select the `id`
-     * const enumsWithIdOnly = await prisma.enums.findMany({ select: { id: true } })
+     * const ticketWithIdOnly = await prisma.ticket.findMany({ select: { id: true } })
      * 
      */
-    findMany<T extends EnumsFindManyArgs>(args?: SelectSubset<T, EnumsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "findMany">>
+    findMany<T extends TicketFindManyArgs>(args?: SelectSubset<T, TicketFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findMany">>
 
     /**
-     * Create a Enums.
-     * @param {EnumsCreateArgs} args - Arguments to create a Enums.
+     * Create a Ticket.
+     * @param {TicketCreateArgs} args - Arguments to create a Ticket.
      * @example
-     * // Create one Enums
-     * const Enums = await prisma.enums.create({
+     * // Create one Ticket
+     * const Ticket = await prisma.ticket.create({
      *   data: {
-     *     // ... data to create a Enums
+     *     // ... data to create a Ticket
      *   }
      * })
      * 
      */
-    create<T extends EnumsCreateArgs>(args: SelectSubset<T, EnumsCreateArgs<ExtArgs>>): Prisma__EnumsClient<$Result.GetResult<Prisma.$EnumsPayload<ExtArgs>, T, "create">, never, ExtArgs>
+    create<T extends TicketCreateArgs>(args: SelectSubset<T, TicketCreateArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "create">, never, ExtArgs>
 
     /**
-     * Create many Enums.
-     * @param {EnumsCreateManyArgs} args - Arguments to create many Enums.
+     * Create many Tickets.
+     * @param {TicketCreateManyArgs} args - Arguments to create many Tickets.
      * @example
-     * // Create many Enums
-     * const enums = await prisma.enums.createMany({
+     * // Create many Tickets
+     * const ticket = await prisma.ticket.createMany({
      *   data: [
      *     // ... provide data here
      *   ]
      * })
      *     
      */
-    createMany<T extends EnumsCreateManyArgs>(args?: SelectSubset<T, EnumsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+    createMany<T extends TicketCreateManyArgs>(args?: SelectSubset<T, TicketCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
 
     /**
-     * Create many Enums and returns the data saved in the database.
-     * @param {EnumsCreateManyAndReturnArgs} args - Arguments to create many Enums.
+     * Create many Tickets and returns the data saved in the database.
+     * @param {TicketCreateManyAndReturnArgs} args - Arguments to create many Tickets.
      * @example
-     * // Create many Enums
-     * const enums = await prisma.enums.createManyAndReturn({
+     * // Create many Tickets
+     * const ticket = await prisma.ticket.createManyAndReturn({
      *   data: [
      *     // ... provide data here
      *   ]
      * })
      * 
-     * // Create many Enums and only return the `id`
-     * const enumsWithIdOnly = await prisma.enums.createManyAndReturn({ 
+     * // Create many Tickets and only return the `id`
+     * const ticketWithIdOnly = await prisma.ticket.createManyAndReturn({ 
      *   select: { id: true },
      *   data: [
      *     // ... provide data here
@@ -12593,7 +12802,911 @@ export namespace Prisma {
      * 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 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">>
 
     /**
      * Delete a Enums.
@@ -13296,6 +14409,20 @@ 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',
@@ -13430,35 +14557,63 @@ export namespace Prisma {
   /**
    * Reference to a field of type 'TagType'
    */
-  export type EnumTagTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, '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[]'>
     
 
 
   /**
-   * Reference to a field of type 'TagType[]'
+   * Reference to a field of type 'TicketType'
    */
-  export type ListEnumTagTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TagType[]'>
+  export type EnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType'>
     
 
 
   /**
-   * Reference to a field of type 'Json'
+   * Reference to a field of type 'TicketType[]'
    */
-  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
+  export type ListEnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType[]'>
     
 
 
   /**
-   * Reference to a field of type 'MessageState'
+   * Reference to a field of type 'TicketStatus'
    */
-  export type EnumMessageStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageState'>
+  export type EnumTicketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketStatus'>
     
 
 
   /**
-   * Reference to a field of type 'MessageState[]'
+   * Reference to a field of type 'TicketStatus[]'
    */
-  export type ListEnumMessageStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageState[]'>
+  export type ListEnumTicketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketStatus[]'>
     
 
 
@@ -14027,6 +15182,7 @@ export namespace Prisma {
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
     subEvents?: EventListRelationFilter
+    tickets?: TicketListRelationFilter
   }
 
   export type EventOrderByWithRelationInput = {
@@ -14045,6 +15201,7 @@ export namespace Prisma {
     tagConfirmed?: TagOrderByWithRelationInput
     supraEvent?: EventOrderByWithRelationInput
     subEvents?: EventOrderByRelationAggregateInput
+    tickets?: TicketOrderByRelationAggregateInput
   }
 
   export type EventWhereUniqueInput = Prisma.AtLeast<{
@@ -14066,6 +15223,7 @@ export namespace Prisma {
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
     subEvents?: EventListRelationFilter
+    tickets?: TicketListRelationFilter
   }, "id" | "tagAssistedId" | "tagConfirmedId">
 
   export type EventOrderByWithAggregationInput = {
@@ -14272,6 +15430,76 @@ 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[]
@@ -14905,6 +16133,7 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateInput = {
@@ -14919,6 +16148,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventUpdateInput = {
@@ -14933,6 +16163,7 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateInput = {
@@ -14947,6 +16178,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventCreateManyInput = {
@@ -15169,6 +16401,82 @@ 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
@@ -15781,10 +17089,20 @@ 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
@@ -15964,6 +17282,78 @@ 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>
@@ -16785,6 +18175,13 @@ 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[]
@@ -16792,6 +18189,13 @@ 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
@@ -16842,6 +18246,20 @@ 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[]
@@ -16856,6 +18274,20 @@ 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[]
@@ -16916,6 +18348,28 @@ 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
   }
@@ -17187,6 +18641,40 @@ 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>
@@ -18188,6 +19676,7 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTagAssistedInput = {
@@ -18201,6 +19690,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTagAssistedInput = {
@@ -18219,6 +19709,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutTagConfirmedInput = {
@@ -18232,6 +19723,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutTagConfirmedInput = {
@@ -18409,6 +19901,7 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTagAssistedInput = {
@@ -18422,6 +19915,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUpsertWithoutTagConfirmedInput = {
@@ -18446,6 +19940,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutTagConfirmedInput = {
@@ -18459,6 +19954,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type AccountUpsertWithWhereUniqueWithoutTagsInput = {
@@ -18669,6 +20165,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutSubEventsInput = {
@@ -18682,6 +20179,7 @@ export namespace Prisma {
     supraEventId?: string | null
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutSubEventsInput = {
@@ -18700,6 +20198,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutSupraEventInput = {
@@ -18713,6 +20212,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutSupraEventInput = {
@@ -18725,6 +20225,36 @@ 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>
@@ -18848,6 +20378,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutSubEventsInput = {
@@ -18861,6 +20392,7 @@ export namespace Prisma {
     supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUpsertWithWhereUniqueWithoutSupraEventInput = {
@@ -18895,6 +20427,36 @@ 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
@@ -18906,6 +20468,7 @@ export namespace Prisma {
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
   }
 
   export type EventUncheckedCreateWithoutFolderInput = {
@@ -18919,6 +20482,7 @@ export namespace Prisma {
     created_at?: Date | string
     updated_at?: Date | string
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
   }
 
   export type EventCreateOrConnectWithoutFolderInput = {
@@ -19059,6 +20623,78 @@ 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
@@ -19726,6 +21362,16 @@ 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
@@ -19737,6 +21383,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutSupraEventInput = {
@@ -19750,6 +21397,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateManyWithoutSupraEventInput = {
@@ -19764,6 +21412,36 @@ 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
@@ -19787,6 +21465,7 @@ export namespace Prisma {
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateWithoutFolderInput = {
@@ -19800,6 +21479,7 @@ export namespace Prisma {
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
   export type EventUncheckedUpdateManyWithoutFolderInput = {
@@ -19887,6 +21567,10 @@ 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
      */