expo-backend-types 0.32.0 → 0.33.0

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
  * 
@@ -106,6 +111,24 @@ export const MessageState: {
 export type MessageState = (typeof MessageState)[keyof typeof MessageState]
 
 
+export const TicketType: {
+  PARTICIPANT: 'PARTICIPANT',
+  STAFF: 'STAFF',
+  SPECTATOR: 'SPECTATOR'
+};
+
+export type TicketType = (typeof TicketType)[keyof typeof TicketType]
+
+
+export const TicketStatus: {
+  BOOKED: 'BOOKED',
+  PAID: 'PAID',
+  FREE: 'FREE'
+};
+
+export type TicketStatus = (typeof TicketStatus)[keyof typeof TicketStatus]
+
+
 export const TemplateStatus: {
   APPROVED: 'APPROVED',
   PENDING: 'PENDING',
@@ -123,15 +146,6 @@ export const TemplateCategory: {
 
 export type TemplateCategory = (typeof TemplateCategory)[keyof typeof TemplateCategory]
 
-
-export const TicketType: {
-  PARTICIPANT: 'PARTICIPANT',
-  STAFF: 'STAFF',
-  SPECTATOR: 'SPECTATOR'
-};
-
-export type TicketType = (typeof TicketType)[keyof typeof TicketType]
-
 }
 
 export type Role = $Enums.Role
@@ -146,6 +160,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
@@ -154,10 +176,6 @@ export type TemplateCategory = $Enums.TemplateCategory
 
 export const TemplateCategory: typeof $Enums.TemplateCategory
 
-export type TicketType = $Enums.TicketType
-
-export const TicketType: typeof $Enums.TicketType
-
 /**
  * ##  Prisma Client ʲˢ
  * 
@@ -381,6 +399,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:
@@ -851,6 +879,7 @@ export namespace Prisma {
     EventFolder: 'EventFolder',
     Message: 'Message',
     CannedResponse: 'CannedResponse',
+    Ticket: 'Ticket',
     Enums: 'Enums',
     EventTicket: 'EventTicket'
   };
@@ -868,7 +897,7 @@ export namespace Prisma {
 
   export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
     meta: {
-      modelProps: "account" | "profile" | "location" | "comment" | "tag" | "tagGroup" | "event" | "eventFolder" | "message" | "cannedResponse" | "enums" | "eventTicket"
+      modelProps: "account" | "profile" | "location" | "comment" | "tag" | "tagGroup" | "event" | "eventFolder" | "message" | "cannedResponse" | "ticket" | "enums" | "eventTicket"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -1572,6 +1601,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
@@ -2109,12 +2208,14 @@ export namespace Prisma {
    */
 
   export type EventCountOutputType = {
+    tickets: number
     subEvents: number
     tags: number
     eventTickets: number
   }
 
   export type EventCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    tickets?: boolean | EventCountOutputTypeCountTicketsArgs
     subEvents?: boolean | EventCountOutputTypeCountSubEventsArgs
     tags?: boolean | EventCountOutputTypeCountTagsArgs
     eventTickets?: boolean | EventCountOutputTypeCountEventTicketsArgs
@@ -2131,6 +2232,13 @@ export namespace Prisma {
     select?: EventCountOutputTypeSelect<ExtArgs> | null
   }
 
+  /**
+   * EventCountOutputType without action
+   */
+  export type EventCountOutputTypeCountTicketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: TicketWhereInput
+  }
+
   /**
    * EventCountOutputType without action
    */
@@ -8820,6 +8928,7 @@ export namespace Prisma {
     tagAssisted?: boolean | TagDefaultArgs<ExtArgs>
     tagConfirmed?: boolean | TagDefaultArgs<ExtArgs>
     supraEvent?: boolean | Event$supraEventArgs<ExtArgs>
+    tickets?: boolean | Event$ticketsArgs<ExtArgs>
     subEvents?: boolean | Event$subEventsArgs<ExtArgs>
     tags?: boolean | Event$tagsArgs<ExtArgs>
     eventTickets?: boolean | Event$eventTicketsArgs<ExtArgs>
@@ -8867,6 +8976,7 @@ export namespace Prisma {
     tagAssisted?: boolean | TagDefaultArgs<ExtArgs>
     tagConfirmed?: boolean | TagDefaultArgs<ExtArgs>
     supraEvent?: boolean | Event$supraEventArgs<ExtArgs>
+    tickets?: boolean | Event$ticketsArgs<ExtArgs>
     subEvents?: boolean | Event$subEventsArgs<ExtArgs>
     tags?: boolean | Event$tagsArgs<ExtArgs>
     eventTickets?: boolean | Event$eventTicketsArgs<ExtArgs>
@@ -8886,6 +8996,7 @@ export namespace Prisma {
       tagAssisted: Prisma.$TagPayload<ExtArgs>
       tagConfirmed: Prisma.$TagPayload<ExtArgs>
       supraEvent: Prisma.$EventPayload<ExtArgs> | null
+      tickets: Prisma.$TicketPayload<ExtArgs>[]
       subEvents: Prisma.$EventPayload<ExtArgs>[]
       tags: Prisma.$TagPayload<ExtArgs>[]
       eventTickets: Prisma.$EventTicketPayload<ExtArgs>[]
@@ -9272,6 +9383,7 @@ export namespace Prisma {
     tagAssisted<T extends TagDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TagDefaultArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
     tagConfirmed<T extends TagDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TagDefaultArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
     supraEvent<T extends Event$supraEventArgs<ExtArgs> = {}>(args?: Subset<T, Event$supraEventArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
+    tickets<T extends Event$ticketsArgs<ExtArgs> = {}>(args?: Subset<T, Event$ticketsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findMany"> | Null>
     subEvents<T extends Event$subEventsArgs<ExtArgs> = {}>(args?: Subset<T, Event$subEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findMany"> | Null>
     tags<T extends Event$tagsArgs<ExtArgs> = {}>(args?: Subset<T, Event$tagsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findMany"> | Null>
     eventTickets<T extends Event$eventTicketsArgs<ExtArgs> = {}>(args?: Subset<T, Event$eventTicketsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventTicketPayload<ExtArgs>, T, "findMany"> | Null>
@@ -9664,6 +9776,26 @@ export namespace Prisma {
     where?: EventWhereInput
   }
 
+  /**
+   * Event.tickets
+   */
+  export type Event$ticketsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Ticket
+     */
+    select?: TicketSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: TicketInclude<ExtArgs> | null
+    where?: TicketWhereInput
+    orderBy?: TicketOrderByWithRelationInput | TicketOrderByWithRelationInput[]
+    cursor?: TicketWhereUniqueInput
+    take?: number
+    skip?: number
+    distinct?: TicketScalarFieldEnum | TicketScalarFieldEnum[]
+  }
+
   /**
    * Event.subEvents
    */
@@ -12519,205 +12651,1174 @@ 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 Ticket
+     * const ticket = await prisma.ticket.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends TicketFindUniqueOrThrowArgs>(args: SelectSubset<T, TicketFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
+
+    /**
+     * 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 {TicketFindFirstArgs} args - Arguments to find a Ticket
+     * @example
+     * // Get one Ticket
+     * const ticket = await prisma.ticket.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends TicketFindFirstArgs>(args?: SelectSubset<T, TicketFindFirstArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
+
+    /**
+     * 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 {TicketFindFirstOrThrowArgs} args - Arguments to find a Ticket
+     * @example
+     * // Get one Ticket
+     * const ticket = await prisma.ticket.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends TicketFindFirstOrThrowArgs>(args?: SelectSubset<T, TicketFindFirstOrThrowArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
+
+    /**
+     * 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 {TicketFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Tickets
+     * const tickets = await prisma.ticket.findMany()
+     * 
+     * // Get first 10 Tickets
+     * const tickets = await prisma.ticket.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const ticketWithIdOnly = await prisma.ticket.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends TicketFindManyArgs>(args?: SelectSubset<T, TicketFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "findMany">>
+
+    /**
+     * Create a Ticket.
+     * @param {TicketCreateArgs} args - Arguments to create a Ticket.
+     * @example
+     * // Create one Ticket
+     * const Ticket = await prisma.ticket.create({
+     *   data: {
+     *     // ... data to create a Ticket
+     *   }
+     * })
+     * 
+     */
+    create<T extends TicketCreateArgs>(args: SelectSubset<T, TicketCreateArgs<ExtArgs>>): Prisma__TicketClient<$Result.GetResult<Prisma.$TicketPayload<ExtArgs>, T, "create">, never, ExtArgs>
+
+    /**
+     * Create many Tickets.
+     * @param {TicketCreateManyArgs} args - Arguments to create many Tickets.
+     * @example
+     * // Create many Tickets
+     * const ticket = await prisma.ticket.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends TicketCreateManyArgs>(args?: SelectSubset<T, TicketCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many Tickets and returns the data saved in the database.
+     * @param {TicketCreateManyAndReturnArgs} args - Arguments to create many Tickets.
+     * @example
+     * // Create many Tickets
+     * const ticket = await prisma.ticket.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many Tickets and only return the `id`
+     * const ticketWithIdOnly = await prisma.ticket.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 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({
@@ -14528,6 +15629,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',
@@ -14708,44 +15823,58 @@ export namespace Prisma {
 
 
   /**
-   * Reference to a field of type 'TemplateStatus'
+   * Reference to a field of type 'TicketType'
    */
-  export type EnumTemplateStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateStatus'>
+  export type EnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType'>
     
 
 
   /**
-   * Reference to a field of type 'TemplateStatus[]'
+   * Reference to a field of type 'TicketType[]'
    */
-  export type ListEnumTemplateStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateStatus[]'>
+  export type ListEnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType[]'>
     
 
 
   /**
-   * Reference to a field of type 'TemplateCategory'
+   * Reference to a field of type 'TicketStatus'
    */
-  export type EnumTemplateCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateCategory'>
+  export type EnumTicketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketStatus'>
     
 
 
   /**
-   * Reference to a field of type 'TemplateCategory[]'
+   * Reference to a field of type 'TicketStatus[]'
    */
-  export type ListEnumTemplateCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateCategory[]'>
+  export type ListEnumTicketStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketStatus[]'>
     
 
 
   /**
-   * Reference to a field of type 'TicketType'
+   * Reference to a field of type 'TemplateStatus'
    */
-  export type EnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType'>
+  export type EnumTemplateStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateStatus'>
     
 
 
   /**
-   * Reference to a field of type 'TicketType[]'
+   * Reference to a field of type 'TemplateStatus[]'
    */
-  export type ListEnumTicketTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TicketType[]'>
+  export type ListEnumTemplateStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateStatus[]'>
+    
+
+
+  /**
+   * Reference to a field of type 'TemplateCategory'
+   */
+  export type EnumTemplateCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateCategory'>
+    
+
+
+  /**
+   * Reference to a field of type 'TemplateCategory[]'
+   */
+  export type ListEnumTemplateCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TemplateCategory[]'>
     
   /**
    * Deep Input Types
@@ -15291,6 +16420,7 @@ export namespace Prisma {
     tagAssisted?: XOR<TagRelationFilter, TagWhereInput>
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
+    tickets?: TicketListRelationFilter
     subEvents?: EventListRelationFilter
     tags?: TagListRelationFilter
     eventTickets?: EventTicketListRelationFilter
@@ -15314,6 +16444,7 @@ export namespace Prisma {
     tagAssisted?: TagOrderByWithRelationInput
     tagConfirmed?: TagOrderByWithRelationInput
     supraEvent?: EventOrderByWithRelationInput
+    tickets?: TicketOrderByRelationAggregateInput
     subEvents?: EventOrderByRelationAggregateInput
     tags?: TagOrderByRelationAggregateInput
     eventTickets?: EventTicketOrderByRelationAggregateInput
@@ -15340,6 +16471,7 @@ export namespace Prisma {
     tagAssisted?: XOR<TagRelationFilter, TagWhereInput>
     tagConfirmed?: XOR<TagRelationFilter, TagWhereInput>
     supraEvent?: XOR<EventNullableRelationFilter, EventWhereInput> | null
+    tickets?: TicketListRelationFilter
     subEvents?: EventListRelationFilter
     tags?: TagListRelationFilter
     eventTickets?: EventTicketListRelationFilter
@@ -15555,6 +16687,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[]
@@ -16261,6 +17463,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tags?: TagCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
@@ -16280,6 +17483,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
@@ -16299,6 +17503,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
@@ -16318,6 +17523,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
@@ -16552,6 +17758,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
@@ -17237,12 +18519,22 @@ export namespace Prisma {
     isNot?: TagWhereInput
   }
 
+  export type TicketListRelationFilter = {
+    every?: TicketWhereInput
+    some?: TicketWhereInput
+    none?: TicketWhereInput
+  }
+
   export type EventTicketListRelationFilter = {
     every?: EventTicketWhereInput
     some?: EventTicketWhereInput
     none?: EventTicketWhereInput
   }
 
+  export type TicketOrderByRelationAggregateInput = {
+    _count?: SortOrder
+  }
+
   export type EventTicketOrderByRelationAggregateInput = {
     _count?: SortOrder
   }
@@ -17413,28 +18705,100 @@ export namespace Prisma {
 
   export type CannedResponseCountOrderByAggregateInput = {
     id?: SortOrder
-    name?: SortOrder
-    content?: SortOrder
+    name?: SortOrder
+    content?: SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+  }
+
+  export type CannedResponseMaxOrderByAggregateInput = {
+    id?: SortOrder
+    name?: SortOrder
+    content?: SortOrder
+    created_at?: SortOrder
+    updated_at?: SortOrder
+  }
+
+  export type CannedResponseMinOrderByAggregateInput = {
+    id?: SortOrder
+    name?: SortOrder
+    content?: SortOrder
+    created_at?: SortOrder
+    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 CannedResponseMaxOrderByAggregateInput = {
+  export type TicketMaxOrderByAggregateInput = {
     id?: SortOrder
-    name?: SortOrder
-    content?: SortOrder
+    eventId?: SortOrder
+    type?: SortOrder
+    status?: SortOrder
+    fullName?: SortOrder
+    mail?: SortOrder
     created_at?: SortOrder
     updated_at?: SortOrder
   }
 
-  export type CannedResponseMinOrderByAggregateInput = {
+  export type TicketMinOrderByAggregateInput = {
     id?: SortOrder
-    name?: SortOrder
-    content?: 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>
@@ -17487,13 +18851,6 @@ export namespace Prisma {
     _max?: NestedEnumTemplateCategoryFilter<$PrismaModel>
   }
 
-  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 FloatNullableFilter<$PrismaModel = never> = {
     equals?: number | FloatFieldRefInput<$PrismaModel> | null
     in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
@@ -17505,11 +18862,6 @@ export namespace Prisma {
     not?: NestedFloatNullableFilter<$PrismaModel> | number | null
   }
 
-  export type EventRelationFilter = {
-    is?: EventWhereInput
-    isNot?: EventWhereInput
-  }
-
   export type EventTicketCountOrderByAggregateInput = {
     id?: SortOrder
     eventId?: SortOrder
@@ -17550,16 +18902,6 @@ export namespace Prisma {
     price?: 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 FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
     equals?: number | FloatFieldRefInput<$PrismaModel> | null
     in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
@@ -18376,6 +19718,13 @@ export namespace Prisma {
     connect?: EventWhereUniqueInput
   }
 
+  export type TicketCreateNestedManyWithoutEventInput = {
+    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
+    createMany?: TicketCreateManyEventInputEnvelope
+    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+  }
+
   export type EventCreateNestedManyWithoutSupraEventInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18396,6 +19745,13 @@ export namespace Prisma {
     connect?: EventTicketWhereUniqueInput | EventTicketWhereUniqueInput[]
   }
 
+  export type TicketUncheckedCreateNestedManyWithoutEventInput = {
+    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[]
@@ -18452,6 +19808,20 @@ export namespace Prisma {
     update?: XOR<XOR<EventUpdateToOneWithWhereWithoutSubEventsInput, EventUpdateWithoutSubEventsInput>, EventUncheckedUpdateWithoutSubEventsInput>
   }
 
+  export type TicketUpdateManyWithoutEventNestedInput = {
+    create?: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput> | TicketCreateWithoutEventInput[] | TicketUncheckedCreateWithoutEventInput[]
+    connectOrCreate?: TicketCreateOrConnectWithoutEventInput | TicketCreateOrConnectWithoutEventInput[]
+    upsert?: TicketUpsertWithWhereUniqueWithoutEventInput | TicketUpsertWithWhereUniqueWithoutEventInput[]
+    createMany?: TicketCreateManyEventInputEnvelope
+    set?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    disconnect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    delete?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    connect?: TicketWhereUniqueInput | TicketWhereUniqueInput[]
+    update?: TicketUpdateWithWhereUniqueWithoutEventInput | TicketUpdateWithWhereUniqueWithoutEventInput[]
+    updateMany?: TicketUpdateManyWithWhereWithoutEventInput | TicketUpdateManyWithWhereWithoutEventInput[]
+    deleteMany?: TicketScalarWhereInput | TicketScalarWhereInput[]
+  }
+
   export type EventUpdateManyWithoutSupraEventNestedInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18493,6 +19863,20 @@ export namespace Prisma {
     deleteMany?: EventTicketScalarWhereInput | EventTicketScalarWhereInput[]
   }
 
+  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 EventUncheckedUpdateManyWithoutSupraEventNestedInput = {
     create?: XOR<EventCreateWithoutSupraEventInput, EventUncheckedCreateWithoutSupraEventInput> | EventCreateWithoutSupraEventInput[] | EventUncheckedCreateWithoutSupraEventInput[]
     connectOrCreate?: EventCreateOrConnectWithoutSupraEventInput | EventCreateOrConnectWithoutSupraEventInput[]
@@ -18594,6 +19978,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
   }
@@ -18608,10 +20014,6 @@ export namespace Prisma {
     connect?: EventWhereUniqueInput
   }
 
-  export type EnumTicketTypeFieldUpdateOperationsInput = {
-    set?: $Enums.TicketType
-  }
-
   export type NullableFloatFieldUpdateOperationsInput = {
     set?: number | null
     increment?: number
@@ -18891,6 +20293,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>
@@ -18925,13 +20361,6 @@ export namespace Prisma {
     _max?: NestedEnumTemplateCategoryFilter<$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 NestedFloatNullableFilter<$PrismaModel = never> = {
     equals?: number | FloatFieldRefInput<$PrismaModel> | null
     in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
@@ -18943,16 +20372,6 @@ export namespace Prisma {
     not?: NestedFloatNullableFilter<$PrismaModel> | number | null
   }
 
-  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 NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
     equals?: number | FloatFieldRefInput<$PrismaModel> | null
     in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
@@ -19944,6 +21363,7 @@ export namespace Prisma {
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tags?: TagCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
@@ -19962,6 +21382,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
@@ -19985,6 +21406,7 @@ export namespace Prisma {
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tags?: TagCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
@@ -20003,6 +21425,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
@@ -20146,6 +21569,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
@@ -20164,6 +21588,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
@@ -20226,6 +21651,7 @@ export namespace Prisma {
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
@@ -20244,6 +21670,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
@@ -20273,6 +21700,7 @@ export namespace Prisma {
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
@@ -20291,6 +21719,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
@@ -20548,6 +21977,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     tags?: TagCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
   }
@@ -20566,6 +21996,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
   }
@@ -20575,6 +22006,36 @@ export namespace Prisma {
     create: XOR<EventCreateWithoutSubEventsInput, EventUncheckedCreateWithoutSubEventsInput>
   }
 
+  export type TicketCreateWithoutEventInput = {
+    id?: string
+    type: $Enums.TicketType
+    status: $Enums.TicketStatus
+    fullName: string
+    mail: string
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
+  export type TicketUncheckedCreateWithoutEventInput = {
+    id?: string
+    type: $Enums.TicketType
+    status: $Enums.TicketStatus
+    fullName: string
+    mail: string
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
+  export type TicketCreateOrConnectWithoutEventInput = {
+    where: TicketWhereUniqueInput
+    create: XOR<TicketCreateWithoutEventInput, TicketUncheckedCreateWithoutEventInput>
+  }
+
+  export type TicketCreateManyEventInputEnvelope = {
+    data: TicketCreateManyEventInput | TicketCreateManyEventInput[]
+    skipDuplicates?: boolean
+  }
+
   export type EventCreateWithoutSupraEventInput = {
     id?: string
     name: string
@@ -20588,6 +22049,7 @@ export namespace Prisma {
     folder?: EventFolderCreateNestedOneWithoutEventsInput
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tags?: TagCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
@@ -20606,6 +22068,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
@@ -20812,6 +22275,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
@@ -20830,10 +22294,41 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
 
+  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 EventUpsertWithWhereUniqueWithoutSupraEventInput = {
     where: EventWhereUniqueInput
     update: XOR<EventUpdateWithoutSupraEventInput, EventUncheckedUpdateWithoutSupraEventInput>
@@ -20908,6 +22403,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tags?: TagCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketCreateNestedManyWithoutEventInput
@@ -20926,6 +22422,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
     eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
@@ -21069,6 +22566,98 @@ export namespace Prisma {
     tags?: TagUncheckedUpdateManyWithoutProfilesNestedInput
   }
 
+  export type EventCreateWithoutTicketsInput = {
+    id?: string
+    name: string
+    date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
+    location: string
+    active?: boolean
+    created_at?: Date | string
+    updated_at?: Date | string
+    folder?: EventFolderCreateNestedOneWithoutEventsInput
+    tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
+    tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
+    supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    subEvents?: EventCreateNestedManyWithoutSupraEventInput
+    tags?: TagCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketCreateNestedManyWithoutEventInput
+  }
+
+  export type EventUncheckedCreateWithoutTicketsInput = {
+    id?: string
+    name: string
+    date: Date | string
+    startingDate: Date | string
+    endingDate: Date | string
+    location: string
+    folderId?: string | null
+    tagAssistedId: string
+    tagConfirmedId: string
+    supraEventId?: string | null
+    active?: boolean
+    created_at?: Date | string
+    updated_at?: Date | string
+    subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
+    tags?: TagUncheckedCreateNestedManyWithoutEventInput
+    eventTickets?: EventTicketUncheckedCreateNestedManyWithoutEventInput
+  }
+
+  export type EventCreateOrConnectWithoutTicketsInput = {
+    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
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    folder?: EventFolderUpdateOneWithoutEventsNestedInput
+    tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
+    tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
+    supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    subEvents?: EventUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
+  }
+
+  export type EventUncheckedUpdateWithoutTicketsInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    name?: StringFieldUpdateOperationsInput | string
+    date?: DateTimeFieldUpdateOperationsInput | Date | string
+    startingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    endingDate?: DateTimeFieldUpdateOperationsInput | Date | string
+    location?: StringFieldUpdateOperationsInput | string
+    folderId?: NullableStringFieldUpdateOperationsInput | string | null
+    tagAssistedId?: StringFieldUpdateOperationsInput | string
+    tagConfirmedId?: StringFieldUpdateOperationsInput | string
+    supraEventId?: NullableStringFieldUpdateOperationsInput | string | null
+    active?: BoolFieldUpdateOperationsInput | boolean
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
+    tags?: TagUncheckedUpdateManyWithoutEventNestedInput
+    eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
+  }
+
   export type EventCreateWithoutEventTicketsInput = {
     id?: string
     name: string
@@ -21083,6 +22672,7 @@ export namespace Prisma {
     tagAssisted: TagCreateNestedOneWithoutAssistedEventInput
     tagConfirmed: TagCreateNestedOneWithoutConfirmedEventInput
     supraEvent?: EventCreateNestedOneWithoutSubEventsInput
+    tickets?: TicketCreateNestedManyWithoutEventInput
     subEvents?: EventCreateNestedManyWithoutSupraEventInput
     tags?: TagCreateNestedManyWithoutEventInput
   }
@@ -21101,6 +22691,7 @@ export namespace Prisma {
     active?: boolean
     created_at?: Date | string
     updated_at?: Date | string
+    tickets?: TicketUncheckedCreateNestedManyWithoutEventInput
     subEvents?: EventUncheckedCreateNestedManyWithoutSupraEventInput
     tags?: TagUncheckedCreateNestedManyWithoutEventInput
   }
@@ -21135,6 +22726,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
   }
@@ -21153,6 +22745,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
   }
@@ -21790,6 +23383,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
   }
@@ -21808,6 +23402,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
   }
@@ -21872,6 +23467,16 @@ export namespace Prisma {
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
+  export type TicketCreateManyEventInput = {
+    id?: string
+    type: $Enums.TicketType
+    status: $Enums.TicketStatus
+    fullName: string
+    mail: string
+    created_at?: Date | string
+    updated_at?: Date | string
+  }
+
   export type EventCreateManySupraEventInput = {
     id?: string
     name: string
@@ -21896,6 +23501,36 @@ export namespace Prisma {
     updated_at?: Date | string
   }
 
+  export type TicketUpdateWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
+    fullName?: StringFieldUpdateOperationsInput | string
+    mail?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type TicketUncheckedUpdateWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
+    fullName?: StringFieldUpdateOperationsInput | string
+    mail?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type TicketUncheckedUpdateManyWithoutEventInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    type?: EnumTicketTypeFieldUpdateOperationsInput | $Enums.TicketType
+    status?: EnumTicketStatusFieldUpdateOperationsInput | $Enums.TicketStatus
+    fullName?: StringFieldUpdateOperationsInput | string
+    mail?: StringFieldUpdateOperationsInput | string
+    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
   export type EventUpdateWithoutSupraEventInput = {
     id?: StringFieldUpdateOperationsInput | string
     name?: StringFieldUpdateOperationsInput | string
@@ -21909,6 +23544,7 @@ export namespace Prisma {
     folder?: EventFolderUpdateOneWithoutEventsNestedInput
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
@@ -21927,6 +23563,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
@@ -22039,6 +23676,7 @@ export namespace Prisma {
     tagAssisted?: TagUpdateOneRequiredWithoutAssistedEventNestedInput
     tagConfirmed?: TagUpdateOneRequiredWithoutConfirmedEventNestedInput
     supraEvent?: EventUpdateOneWithoutSubEventsNestedInput
+    tickets?: TicketUpdateManyWithoutEventNestedInput
     subEvents?: EventUpdateManyWithoutSupraEventNestedInput
     tags?: TagUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUpdateManyWithoutEventNestedInput
@@ -22057,6 +23695,7 @@ export namespace Prisma {
     active?: BoolFieldUpdateOperationsInput | boolean
     created_at?: DateTimeFieldUpdateOperationsInput | Date | string
     updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
+    tickets?: TicketUncheckedUpdateManyWithoutEventNestedInput
     subEvents?: EventUncheckedUpdateManyWithoutSupraEventNestedInput
     tags?: TagUncheckedUpdateManyWithoutEventNestedInput
     eventTickets?: EventTicketUncheckedUpdateManyWithoutEventNestedInput
@@ -22150,6 +23789,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
      */