Interface TicketSetupsDelegate<ExtArgs, GlobalOmitOptions>

Readonlyfields

aggregate

• aggregate<T extends TicketSetupsAggregateArgs<DefaultArgs>>(
      args: Subset<T, TicketSetupsAggregateArgs>,
  ): Prisma.PrismaPromise<GetTicketSetupsAggregateType<T>>

  Allows you to perform aggregations operations on a TicketSetups. Note, that providing undefined is treated as the value not being there. Read more here: https://pris.ly/d/null-undefined

  Type Parameters

  • T extends TicketSetupsAggregateArgs<DefaultArgs>

  Parameters

  • args: Subset<T, TicketSetupsAggregateArgs>

    Select which aggregations you would like to apply and on what fields.

  Returns Prisma.PrismaPromise<GetTicketSetupsAggregateType<T>>

  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,
  })
  Copy

count

• count<T extends TicketSetupsCountArgs<DefaultArgs>>(
      args?: Subset<T, TicketSetupsCountArgs>,
  ): Prisma.PrismaPromise<
      T extends Record<"select", any>
          ? T<T>["select"] extends true
              ? number
              : {
                  [P in string | number | symbol]: P extends keyof TicketSetupsCountAggregateOutputType
                      ? TicketSetupsCountAggregateOutputType[P<P>]
                      : never
              }
          : number,
  >

  Count the number of TicketSetups. Note, that providing undefined is treated as the value not being there. Read more here: https://pris.ly/d/null-undefined

  Type Parameters

  • T extends TicketSetupsCountArgs<DefaultArgs>

  Parameters

  • Optionalargs: Subset<T, TicketSetupsCountArgs>

    Arguments to filter TicketSetups to count.

  Returns Prisma.PrismaPromise<
      T extends Record<"select", any>
          ? T<T>["select"] extends true
              ? number
              : {
                  [P in string | number | symbol]: P extends keyof TicketSetupsCountAggregateOutputType
                      ? TicketSetupsCountAggregateOutputType[P<P>]
                      : never
              }
          : number,
  >

  Example

  // Count the number of TicketSetups
  const count = await prisma.ticketSetups.count({
    where: {
      // ... the filter for the TicketSetups we want to count
    }
  })
  Copy

create

• create<T extends TicketSetupsCreateArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsCreateArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Create a TicketSetups.

  Type Parameters

  • T extends TicketSetupsCreateArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsCreateArgs<ExtArgs>>

    Arguments to create a TicketSetups.

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Create one TicketSetups
  const TicketSetups = await prisma.ticketSetups.create({
    data: {
      // ... data to create a TicketSetups
    }
  })
  Copy

createMany

• createMany<T extends TicketSetupsCreateManyArgs<DefaultArgs>>(
      args?: SelectSubset<T, TicketSetupsCreateManyArgs<ExtArgs>>,
  ): Prisma.PrismaPromise<BatchPayload>

  Create many TicketSetups.

  Type Parameters

  • T extends TicketSetupsCreateManyArgs<DefaultArgs>

  Parameters

  • Optionalargs: SelectSubset<T, TicketSetupsCreateManyArgs<ExtArgs>>

    Arguments to create many TicketSetups.

  Returns Prisma.PrismaPromise<BatchPayload>

  Example

  // Create many TicketSetups
  const ticketSetups = await prisma.ticketSetups.createMany({
    data: [
      // ... provide data here
    ]
  })
  Copy

createManyAndReturn

• createManyAndReturn<T extends TicketSetupsCreateManyAndReturnArgs<DefaultArgs>>(
      args?: SelectSubset<T, TicketSetupsCreateManyAndReturnArgs<ExtArgs>>,
  ): Prisma.PrismaPromise<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>[],
  >

  Create many TicketSetups and returns the data saved in the database.

  Type Parameters

  • T extends TicketSetupsCreateManyAndReturnArgs<DefaultArgs>

  Parameters

  • Optionalargs: SelectSubset<T, TicketSetupsCreateManyAndReturnArgs<ExtArgs>>

    Arguments to create many TicketSetups.

  Returns Prisma.PrismaPromise<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>[],
  >

  Example

  // Create many TicketSetups
  const ticketSetups = await prisma.ticketSetups.createManyAndReturn({
    data: [
      // ... provide data here
    ]
  })
  
  // Create many TicketSetups and only return the `Id`
  const ticketSetupsWithIdOnly = await prisma.ticketSetups.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
  Copy

delete

• delete<T extends TicketSetupsDeleteArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsDeleteArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Delete a TicketSetups.

  Type Parameters

  • T extends TicketSetupsDeleteArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsDeleteArgs<ExtArgs>>

    Arguments to delete one TicketSetups.

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Delete one TicketSetups
  const TicketSetups = await prisma.ticketSetups.delete({
    where: {
      // ... filter to delete one TicketSetups
    }
  })
  Copy

deleteMany

• deleteMany<T extends TicketSetupsDeleteManyArgs<DefaultArgs>>(
      args?: SelectSubset<T, TicketSetupsDeleteManyArgs<ExtArgs>>,
  ): Prisma.PrismaPromise<BatchPayload>

  Delete zero or more TicketSetups.

  Type Parameters

  • T extends TicketSetupsDeleteManyArgs<DefaultArgs>

  Parameters

  • Optionalargs: SelectSubset<T, TicketSetupsDeleteManyArgs<ExtArgs>>

    Arguments to filter TicketSetups to delete.

  Returns Prisma.PrismaPromise<BatchPayload>

  Example

  // Delete a few TicketSetups
  const { count } = await prisma.ticketSetups.deleteMany({
    where: {
      // ... provide filter here
    }
  })
  Copy

findFirst

• findFirst<T extends TicketSetupsFindFirstArgs<DefaultArgs>>(
      args?: SelectSubset<T, TicketSetupsFindFirstArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      null,
      ExtArgs,
      GlobalOmitOptions,
  >

  Find the first TicketSetups 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

  Type Parameters

  • T extends TicketSetupsFindFirstArgs<DefaultArgs>

  Parameters

  • Optionalargs: SelectSubset<T, TicketSetupsFindFirstArgs<ExtArgs>>

    Arguments to find a TicketSetups

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      null,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Get one TicketSetups
  const ticketSetups = await prisma.ticketSetups.findFirst({
    where: {
      // ... provide filter here
    }
  })
  Copy

findFirstOrThrow

• findFirstOrThrow<T extends TicketSetupsFindFirstOrThrowArgs<DefaultArgs>>(
      args?: SelectSubset<T, TicketSetupsFindFirstOrThrowArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Find the first TicketSetups 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

  Type Parameters

  • T extends TicketSetupsFindFirstOrThrowArgs<DefaultArgs>

  Parameters

  • Optionalargs: SelectSubset<T, TicketSetupsFindFirstOrThrowArgs<ExtArgs>>

    Arguments to find a TicketSetups

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Get one TicketSetups
  const ticketSetups = await prisma.ticketSetups.findFirstOrThrow({
    where: {
      // ... provide filter here
    }
  })
  Copy

findMany

• findMany<T extends TicketSetupsFindManyArgs<DefaultArgs>>(
      args?: SelectSubset<T, TicketSetupsFindManyArgs<ExtArgs>>,
  ): Prisma.PrismaPromise<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>[],
  >

  Find zero or more TicketSetups 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

  Type Parameters

  • T extends TicketSetupsFindManyArgs<DefaultArgs>

  Parameters

  • Optionalargs: SelectSubset<T, TicketSetupsFindManyArgs<ExtArgs>>

    Arguments to filter and select certain fields only.

  Returns Prisma.PrismaPromise<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>[],
  >

  Example

  // Get all TicketSetups
  const ticketSetups = await prisma.ticketSetups.findMany()
  
  // Get first 10 TicketSetups
  const ticketSetups = await prisma.ticketSetups.findMany({ take: 10 })
  
  // Only select the `Id`
  const ticketSetupsWithIdOnly = await prisma.ticketSetups.findMany({ select: { Id: true } })
  Copy

findUnique

• findUnique<T extends TicketSetupsFindUniqueArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsFindUniqueArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      null,
      ExtArgs,
      GlobalOmitOptions,
  >

  Find zero or one TicketSetups that matches the filter.

  Type Parameters

  • T extends TicketSetupsFindUniqueArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsFindUniqueArgs<ExtArgs>>

    Arguments to find a TicketSetups

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      null,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Get one TicketSetups
  const ticketSetups = await prisma.ticketSetups.findUnique({
    where: {
      // ... provide filter here
    }
  })
  Copy

findUniqueOrThrow

• findUniqueOrThrow<T extends TicketSetupsFindUniqueOrThrowArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsFindUniqueOrThrowArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Find one TicketSetups that matches the filter or throw an error with error.code='P2025' if no matches were found.

  Type Parameters

  • T extends TicketSetupsFindUniqueOrThrowArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsFindUniqueOrThrowArgs<ExtArgs>>

    Arguments to find a TicketSetups

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Get one TicketSetups
  const ticketSetups = await prisma.ticketSetups.findUniqueOrThrow({
    where: {
      // ... provide filter here
    }
  })
  Copy

groupBy

• groupBy<
      T extends TicketSetupsGroupByArgs<DefaultArgs>,
      HasSelectOrTake extends 0 | 1,
      OrderByArg extends
      
              | {
                  orderBy: | TicketSetupsOrderByWithAggregationInput
                  | TicketSetupsOrderByWithAggregationInput[];
              }
              | {
                  orderBy?: | TicketSetupsOrderByWithAggregationInput
                  | TicketSetupsOrderByWithAggregationInput[];
              },
      OrderFields extends
          | "Id"
          | "GuildId"
          | "CustomId"
          | "MessageTemplateId"
          | "CategoryId"
          | "ChannelType"
          | "TicketChannelName"
          | "EnableTicketsOnlyFromTime"
          | "TicketBlacklistRoles"
          | "TranscriptChannelId"
          | "HasModal"
          | "ModalTitle"
          | "OnlyClaimMode"
          | "TicketLimit"
          | "UserDMWhenCloseMessageTemplateId"
          | "WithTicketFeedback"
          | "TicketFeedbackChannelId"
          | "TicketCreationCooldownPerUser"
          | "AutoCloseAfterInactivity"
          | "AutoCloseAfterTime"
          | "AutoAssignHandler"
          | "AutoReplyMessageTemplateId"
          | "TicketRateLimit"
          | "TicketStatusMessageTemplateId"
          | "TicketStatusMessageId"
          | "TicketStatusChannelId"
          | "AutoCloseAction"
          | "OldTicketCategoryId"
          | "RequiredRoles"
          | "SlashCommandId"
          | "SlashCommandName"
          | "SlashCommandDescription"
          | "TextCommandName"
          | "SendTranscriptToUser",
      ByFields extends Prisma.TicketSetupsScalarFieldEnum,
      ByValid extends 0 | 1,
      HavingFields extends string | number | symbol,
      HavingValid,
      ByEmpty extends 0 | 1,
      InputErrors,
  >(
      args: {
          [key in string | number | symbol]: key extends keyof TicketSetupsGroupByArgs<
              DefaultArgs,
          >
              ? T[key<key>]
              : never
      } & OrderByArg & InputErrors,
  ): {} extends InputErrors
      ? GetTicketSetupsGroupByPayload<T>
      : Prisma.PrismaPromise<InputErrors>

  Group by TicketSetups. Note, that providing undefined is treated as the value not being there. Read more here: https://pris.ly/d/null-undefined

  Type Parameters

  • T extends TicketSetupsGroupByArgs<DefaultArgs>
  • HasSelectOrTake extends 0 | 1
  • OrderByArg extends
        | {
            orderBy: | TicketSetupsOrderByWithAggregationInput
            | TicketSetupsOrderByWithAggregationInput[];
        }
        | {
            orderBy?: | TicketSetupsOrderByWithAggregationInput
            | TicketSetupsOrderByWithAggregationInput[];
        }
  • OrderFields extends
        | "Id"
        | "GuildId"
        | "CustomId"
        | "MessageTemplateId"
        | "CategoryId"
        | "ChannelType"
        | "TicketChannelName"
        | "EnableTicketsOnlyFromTime"
        | "TicketBlacklistRoles"
        | "TranscriptChannelId"
        | "HasModal"
        | "ModalTitle"
        | "OnlyClaimMode"
        | "TicketLimit"
        | "UserDMWhenCloseMessageTemplateId"
        | "WithTicketFeedback"
        | "TicketFeedbackChannelId"
        | "TicketCreationCooldownPerUser"
        | "AutoCloseAfterInactivity"
        | "AutoCloseAfterTime"
        | "AutoAssignHandler"
        | "AutoReplyMessageTemplateId"
        | "TicketRateLimit"
        | "TicketStatusMessageTemplateId"
        | "TicketStatusMessageId"
        | "TicketStatusChannelId"
        | "AutoCloseAction"
        | "OldTicketCategoryId"
        | "RequiredRoles"
        | "SlashCommandId"
        | "SlashCommandName"
        | "SlashCommandDescription"
        | "TextCommandName"
        | "SendTranscriptToUser"
  • ByFields extends Prisma.TicketSetupsScalarFieldEnum
  • ByValid extends 0 | 1
  • HavingFields extends string | number | symbol
  • HavingValid
  • ByEmpty extends 0 | 1
  • InputErrors

  Parameters

  • args: {
        [key in string | number | symbol]: key extends keyof TicketSetupsGroupByArgs<
            DefaultArgs,
        >
            ? T[key<key>]
            : never
    } & OrderByArg & InputErrors

    Group by arguments.

  Returns {} extends InputErrors
      ? GetTicketSetupsGroupByPayload<T>
      : Prisma.PrismaPromise<InputErrors>

  Example

  // Group by city, order by createdAt, get count
  const result = await prisma.user.groupBy({
    by: ['city', 'createdAt'],
    orderBy: {
      createdAt: true
    },
    _count: {
      _all: true
    },
  })
  Copy

update

• update<T extends TicketSetupsUpdateArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsUpdateArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Update one TicketSetups.

  Type Parameters

  • T extends TicketSetupsUpdateArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsUpdateArgs<ExtArgs>>

    Arguments to update one TicketSetups.

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Update one TicketSetups
  const ticketSetups = await prisma.ticketSetups.update({
    where: {
      // ... provide filter here
    },
    data: {
      // ... provide data here
    }
  })
  Copy

updateMany

• updateMany<T extends TicketSetupsUpdateManyArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsUpdateManyArgs<ExtArgs>>,
  ): Prisma.PrismaPromise<BatchPayload>

  Update zero or more TicketSetups. Note, that providing undefined is treated as the value not being there. Read more here: https://pris.ly/d/null-undefined

  Type Parameters

  • T extends TicketSetupsUpdateManyArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsUpdateManyArgs<ExtArgs>>

    Arguments to update one or more rows.

  Returns Prisma.PrismaPromise<BatchPayload>

  Example

  // Update many TicketSetups
  const ticketSetups = await prisma.ticketSetups.updateMany({
    where: {
      // ... provide filter here
    },
    data: {
      // ... provide data here
    }
  })
  Copy

updateManyAndReturn

• updateManyAndReturn<T extends TicketSetupsUpdateManyAndReturnArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsUpdateManyAndReturnArgs<ExtArgs>>,
  ): Prisma.PrismaPromise<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>[],
  >

  Update zero or more TicketSetups and returns the data updated in the database.

  Type Parameters

  • T extends TicketSetupsUpdateManyAndReturnArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsUpdateManyAndReturnArgs<ExtArgs>>

    Arguments to update many TicketSetups.

  Returns Prisma.PrismaPromise<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>[],
  >

  Example

  // Update many TicketSetups
  const ticketSetups = await prisma.ticketSetups.updateManyAndReturn({
    where: {
      // ... provide filter here
    },
    data: [
      // ... provide data here
    ]
  })
  
  // Update zero or more TicketSetups and only return the `Id`
  const ticketSetupsWithIdOnly = await prisma.ticketSetups.updateManyAndReturn({
    select: { Id: true },
    where: {
      // ... provide filter here
    },
    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
  Copy

upsert

• upsert<T extends TicketSetupsUpsertArgs<DefaultArgs>>(
      args: SelectSubset<T, TicketSetupsUpsertArgs<ExtArgs>>,
  ): Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Create or update one TicketSetups.

  Type Parameters

  • T extends TicketSetupsUpsertArgs<DefaultArgs>

  Parameters

  • args: SelectSubset<T, TicketSetupsUpsertArgs<ExtArgs>>

    Arguments to update or create a TicketSetups.

  Returns Prisma__TicketSetupsClient<
      GetFindResult<$TicketSetupsPayload<ExtArgs>, T, GlobalOmitOptions>,
      never,
      ExtArgs,
      GlobalOmitOptions,
  >

  Example

  // Update or create a TicketSetups
  const ticketSetups = await prisma.ticketSetups.upsert({
    create: {
      // ... data to create a TicketSetups
    },
    update: {
      // ... in case it already exists, update
    },
    where: {
      // ... the filter for the TicketSetups we want to update
    }
  })
  Copy