;
+
+
+ /**
+ * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
+ * @example
+ * ```
+ * const [george, bob, alice] = await prisma.$transaction([
+ * prisma.user.create({ data: { name: 'George' } }),
+ * prisma.user.create({ data: { name: 'Bob' } }),
+ * prisma.user.create({ data: { name: 'Alice' } }),
+ * ])
+ * ```
+ *
+ * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
+ */
+ $transaction[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise>
+
+ $transaction(fn: (prisma: Omit) => $Utils.JsPromise, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise
+
+
+ $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs, $Utils.Call, {
+ extArgs: ExtArgs
+ }>>
+
+ /**
+ * `prisma.application`: Exposes CRUD operations for the **application** model.
+ * Example usage:
+ * ```ts
+ * // Fetch zero or more Applications
+ * const applications = await prisma.application.findMany()
+ * ```
+ */
+ get application(): Prisma.applicationDelegate;
+}
+
+export namespace Prisma {
+ export import DMMF = runtime.DMMF
+
+ export type PrismaPromise = $Public.PrismaPromise
+
+ /**
+ * Validator
+ */
+ export import validator = runtime.Public.validator
+
+ /**
+ * Prisma Errors
+ */
+ export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+ export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+ export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+ export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
+ export import PrismaClientValidationError = runtime.PrismaClientValidationError
+
+ /**
+ * Re-export of sql-template-tag
+ */
+ export import sql = runtime.sqltag
+ export import empty = runtime.empty
+ export import join = runtime.join
+ export import raw = runtime.raw
+ export import Sql = runtime.Sql
+
+
+
+ /**
+ * Decimal.js
+ */
+ export import Decimal = runtime.Decimal
+
+ export type DecimalJsLike = runtime.DecimalJsLike
+
+ /**
+ * Metrics
+ */
+ export type Metrics = runtime.Metrics
+ export type Metric = runtime.Metric
+ export type MetricHistogram = runtime.MetricHistogram
+ export type MetricHistogramBucket = runtime.MetricHistogramBucket
+
+ /**
+ * Extensions
+ */
+ export import Extension = $Extensions.UserArgs
+ export import getExtensionContext = runtime.Extensions.getExtensionContext
+ export import Args = $Public.Args
+ export import Payload = $Public.Payload
+ export import Result = $Public.Result
+ export import Exact = $Public.Exact
+
+ /**
+ * Prisma Client JS version: 6.6.0
+ * Query Engine version: f676762280b54cd07c770017ed3711ddde35f37a
+ */
+ export type PrismaVersion = {
+ client: string
+ }
+
+ export const prismaVersion: PrismaVersion
+
+ /**
+ * Utility Types
+ */
+
+
+ export import JsonObject = runtime.JsonObject
+ export import JsonArray = runtime.JsonArray
+ export import JsonValue = runtime.JsonValue
+ export import InputJsonObject = runtime.InputJsonObject
+ export import InputJsonArray = runtime.InputJsonArray
+ export import InputJsonValue = runtime.InputJsonValue
+
+ /**
+ * Types of the values used to represent different kinds of `null` values when working with JSON fields.
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ namespace NullTypes {
+ /**
+ * Type of `Prisma.DbNull`.
+ *
+ * You cannot use other instances of this class. Please use the `Prisma.DbNull` value.
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ class DbNull {
+ private DbNull: never
+ private constructor()
+ }
+
+ /**
+ * Type of `Prisma.JsonNull`.
+ *
+ * You cannot use other instances of this class. Please use the `Prisma.JsonNull` value.
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ class JsonNull {
+ private JsonNull: never
+ private constructor()
+ }
+
+ /**
+ * Type of `Prisma.AnyNull`.
+ *
+ * You cannot use other instances of this class. Please use the `Prisma.AnyNull` value.
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ class AnyNull {
+ private AnyNull: never
+ private constructor()
+ }
+ }
+
+ /**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ export const DbNull: NullTypes.DbNull
+
+ /**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ export const JsonNull: NullTypes.JsonNull
+
+ /**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+ export const AnyNull: NullTypes.AnyNull
+
+ type SelectAndInclude = {
+ select: any
+ include: any
+ }
+
+ type SelectAndOmit = {
+ select: any
+ omit: any
+ }
+
+ /**
+ * Get the type of the value, that the Promise holds.
+ */
+ export type PromiseType> = T extends PromiseLike ? U : T;
+
+ /**
+ * Get the return type of a function which returns a Promise.
+ */
+ export type PromiseReturnType $Utils.JsPromise> = PromiseType>
+
+ /**
+ * From T, pick a set of properties whose keys are in the union K
+ */
+ type Prisma__Pick = {
+ [P in K]: T[P];
+ };
+
+
+ export type Enumerable = T | Array;
+
+ export type RequiredKeys = {
+ [K in keyof T]-?: {} extends Prisma__Pick ? never : K
+ }[keyof T]
+
+ export type TruthyKeys = keyof {
+ [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
+ }
+
+ export type TrueKeys = TruthyKeys>>
+
+ /**
+ * Subset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
+ */
+ export type Subset = {
+ [key in keyof T]: key extends keyof U ? T[key] : never;
+ };
+
+ /**
+ * SelectSubset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
+ * Additionally, it validates, if both select and include are present. If the case, it errors.
+ */
+ export type SelectSubset = {
+ [key in keyof T]: key extends keyof U ? T[key] : never
+ } &
+ (T extends SelectAndInclude
+ ? 'Please either choose `select` or `include`.'
+ : T extends SelectAndOmit
+ ? 'Please either choose `select` or `omit`.'
+ : {})
+
+ /**
+ * Subset + Intersection
+ * @desc From `T` pick properties that exist in `U` and intersect `K`
+ */
+ export type SubsetIntersection = {
+ [key in keyof T]: key extends keyof U ? T[key] : never
+ } &
+ K
+
+ type Without = { [P in Exclude]?: never };
+
+ /**
+ * XOR is needed to have a real mutually exclusive union type
+ * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
+ */
+ type XOR =
+ T extends object ?
+ U extends object ?
+ (Without & U) | (Without & T)
+ : U : T
+
+
+ /**
+ * Is T a Record?
+ */
+ type IsObject = T extends Array
+ ? False
+ : T extends Date
+ ? False
+ : T extends Uint8Array
+ ? False
+ : T extends BigInt
+ ? False
+ : T extends object
+ ? True
+ : False
+
+
+ /**
+ * If it's T[], return T
+ */
+ export type UnEnumerate = T extends Array ? U : T
+
+ /**
+ * From ts-toolbelt
+ */
+
+ type __Either = Omit &
+ {
+ // Merge all but K
+ [P in K]: Prisma__Pick // With K possibilities
+ }[K]
+
+ type EitherStrict = Strict<__Either>
+
+ type EitherLoose = ComputeRaw<__Either>
+
+ type _Either<
+ O extends object,
+ K extends Key,
+ strict extends Boolean
+ > = {
+ 1: EitherStrict
+ 0: EitherLoose
+ }[strict]
+
+ type Either<
+ O extends object,
+ K extends Key,
+ strict extends Boolean = 1
+ > = O extends unknown ? _Either : never
+
+ export type Union = any
+
+ type PatchUndefined = {
+ [K in keyof O]: O[K] extends undefined ? At : O[K]
+ } & {}
+
+ /** Helper Types for "Merge" **/
+ export type IntersectOf = (
+ U extends unknown ? (k: U) => void : never
+ ) extends (k: infer I) => void
+ ? I
+ : never
+
+ export type Overwrite = {
+ [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
+ } & {};
+
+ type _Merge = IntersectOf;
+ }>>;
+
+ type Key = string | number | symbol;
+ type AtBasic = K extends keyof O ? O[K] : never;
+ type AtStrict = O[K & keyof O];
+ type AtLoose = O extends unknown ? AtStrict : never;
+ export type At = {
+ 1: AtStrict;
+ 0: AtLoose;
+ }[strict];
+
+ export type ComputeRaw = A extends Function ? A : {
+ [K in keyof A]: A[K];
+ } & {};
+
+ export type OptionalFlat = {
+ [K in keyof O]?: O[K];
+ } & {};
+
+ type _Record = {
+ [P in K]: T;
+ };
+
+ // cause typescript not to expand types and preserve names
+ type NoExpand = T extends unknown ? T : never;
+
+ // this type assumes the passed object is entirely optional
+ type AtLeast = NoExpand<
+ O extends unknown
+ ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
+ | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
+ : never>;
+
+ type _Strict = U extends unknown ? U & OptionalFlat<_Record, keyof U>, never>> : never;
+
+ export type Strict = ComputeRaw<_Strict>;
+ /** End Helper Types for "Merge" **/
+
+ export type Merge = ComputeRaw<_Merge>>;
+
+ /**
+ A [[Boolean]]
+ */
+ export type Boolean = True | False
+
+ // /**
+ // 1
+ // */
+ export type True = 1
+
+ /**
+ 0
+ */
+ export type False = 0
+
+ export type Not = {
+ 0: 1
+ 1: 0
+ }[B]
+
+ export type Extends = [A1] extends [never]
+ ? 0 // anything `never` is false
+ : A1 extends A2
+ ? 1
+ : 0
+
+ export type Has = Not<
+ Extends, U1>
+ >
+
+ export type Or = {
+ 0: {
+ 0: 0
+ 1: 1
+ }
+ 1: {
+ 0: 1
+ 1: 1
+ }
+ }[B1][B2]
+
+ export type Keys = U extends unknown ? keyof U : never
+
+ type Cast = A extends B ? A : B;
+
+ export const type: unique symbol;
+
+
+
+ /**
+ * Used by group by
+ */
+
+ export type GetScalarType = O extends object ? {
+ [P in keyof T]: P extends keyof O
+ ? O[P]
+ : never
+ } : never
+
+ type FieldPaths<
+ T,
+ U = Omit
+ > = IsObject extends True ? U : T
+
+ type GetHavingFields = {
+ [K in keyof T]: Or<
+ Or, Extends<'AND', K>>,
+ Extends<'NOT', K>
+ > extends True
+ ? // infer is only needed to not hit TS limit
+ // based on the brilliant idea of Pierre-Antoine Mills
+ // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
+ T[K] extends infer TK
+ ? GetHavingFields extends object ? Merge> : never>
+ : never
+ : {} extends FieldPaths
+ ? never
+ : K
+ }[keyof T]
+
+ /**
+ * Convert tuple to union
+ */
+ type _TupleToUnion = T extends (infer E)[] ? E : never
+ type TupleToUnion = _TupleToUnion
+ type MaybeTupleToUnion = T extends any[] ? TupleToUnion : T
+
+ /**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+ type PickEnumerable | keyof T> = Prisma__Pick>
+
+ /**
+ * Exclude all keys with underscores
+ */
+ type ExcludeUnderscoreKeys = T extends `_${string}` ? never : T
+
+
+ export type FieldRef = runtime.FieldRef
+
+ type FieldRefInputType = Model extends never ? never : FieldRef
+
+
+ export const ModelName: {
+ application: 'application'
+ };
+
+ export type ModelName = (typeof ModelName)[keyof typeof ModelName]
+
+
+ export type Datasources = {
+ db?: Datasource
+ }
+
+ interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record> {
+ returns: Prisma.TypeMap
+ }
+
+ export type TypeMap = {
+ globalOmitOptions: {
+ omit: GlobalOmitOptions
+ }
+ meta: {
+ modelProps: "application"
+ txIsolationLevel: Prisma.TransactionIsolationLevel
+ }
+ model: {
+ application: {
+ payload: Prisma.$applicationPayload
+ fields: Prisma.applicationFieldRefs
+ operations: {
+ findUnique: {
+ args: Prisma.applicationFindUniqueArgs
+ result: $Utils.PayloadToResult | null
+ }
+ findUniqueOrThrow: {
+ args: Prisma.applicationFindUniqueOrThrowArgs
+ result: $Utils.PayloadToResult
+ }
+ findFirst: {
+ args: Prisma.applicationFindFirstArgs
+ result: $Utils.PayloadToResult | null
+ }
+ findFirstOrThrow: {
+ args: Prisma.applicationFindFirstOrThrowArgs
+ result: $Utils.PayloadToResult
+ }
+ findMany: {
+ args: Prisma.applicationFindManyArgs
+ result: $Utils.PayloadToResult[]
+ }
+ create: {
+ args: Prisma.applicationCreateArgs
+ result: $Utils.PayloadToResult
+ }
+ createMany: {
+ args: Prisma.applicationCreateManyArgs
+ result: BatchPayload
+ }
+ createManyAndReturn: {
+ args: Prisma.applicationCreateManyAndReturnArgs
+ result: $Utils.PayloadToResult[]
+ }
+ delete: {
+ args: Prisma.applicationDeleteArgs
+ result: $Utils.PayloadToResult
+ }
+ update: {
+ args: Prisma.applicationUpdateArgs
+ result: $Utils.PayloadToResult
+ }
+ deleteMany: {
+ args: Prisma.applicationDeleteManyArgs
+ result: BatchPayload
+ }
+ updateMany: {
+ args: Prisma.applicationUpdateManyArgs
+ result: BatchPayload
+ }
+ updateManyAndReturn: {
+ args: Prisma.applicationUpdateManyAndReturnArgs
+ result: $Utils.PayloadToResult[]
+ }
+ upsert: {
+ args: Prisma.applicationUpsertArgs
+ result: $Utils.PayloadToResult
+ }
+ aggregate: {
+ args: Prisma.ApplicationAggregateArgs
+ result: $Utils.Optional
+ }
+ groupBy: {
+ args: Prisma.applicationGroupByArgs
+ result: $Utils.Optional[]
+ }
+ count: {
+ args: Prisma.applicationCountArgs
+ result: $Utils.Optional | number
+ }
+ }
+ }
+ }
+ } & {
+ other: {
+ payload: any
+ operations: {
+ $executeRaw: {
+ args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
+ result: any
+ }
+ $executeRawUnsafe: {
+ args: [query: string, ...values: any[]],
+ result: any
+ }
+ $queryRaw: {
+ args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
+ result: any
+ }
+ $queryRawUnsafe: {
+ args: [query: string, ...values: any[]],
+ result: any
+ }
+ }
+ }
+ }
+ export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
+ export type DefaultPrismaClient = PrismaClient
+ export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
+ export interface PrismaClientOptions {
+ /**
+ * Overwrites the datasource url from your schema.prisma file
+ */
+ datasources?: Datasources
+ /**
+ * Overwrites the datasource url from your schema.prisma file
+ */
+ datasourceUrl?: string
+ /**
+ * @default "colorless"
+ */
+ errorFormat?: ErrorFormat
+ /**
+ * @example
+ * ```
+ * // Defaults to stdout
+ * log: ['query', 'info', 'warn', 'error']
+ *
+ * // Emit as events
+ * log: [
+ * { emit: 'stdout', level: 'query' },
+ * { emit: 'stdout', level: 'info' },
+ * { emit: 'stdout', level: 'warn' }
+ * { emit: 'stdout', level: 'error' }
+ * ]
+ * ```
+ * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
+ */
+ log?: (LogLevel | LogDefinition)[]
+ /**
+ * The default values for transactionOptions
+ * maxWait ?= 2000
+ * timeout ?= 5000
+ */
+ transactionOptions?: {
+ maxWait?: number
+ timeout?: number
+ isolationLevel?: Prisma.TransactionIsolationLevel
+ }
+ /**
+ * Global configuration for omitting model fields by default.
+ *
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ * omit: {
+ * user: {
+ * password: true
+ * }
+ * }
+ * })
+ * ```
+ */
+ omit?: Prisma.GlobalOmitConfig
+ }
+ export type GlobalOmitConfig = {
+ application?: applicationOmit
+ }
+
+ /* Types for Logging */
+ export type LogLevel = 'info' | 'query' | 'warn' | 'error'
+ export type LogDefinition = {
+ level: LogLevel
+ emit: 'stdout' | 'event'
+ }
+
+ export type GetLogType = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
+ export type GetEvents = T extends Array ?
+ GetLogType | GetLogType | GetLogType | GetLogType
+ : never
+
+ export type QueryEvent = {
+ timestamp: Date
+ query: string
+ params: string
+ duration: number
+ target: string
+ }
+
+ export type LogEvent = {
+ timestamp: Date
+ message: string
+ target: string
+ }
+ /* End Types for Logging */
+
+
+ export type PrismaAction =
+ | 'findUnique'
+ | 'findUniqueOrThrow'
+ | 'findMany'
+ | 'findFirst'
+ | 'findFirstOrThrow'
+ | 'create'
+ | 'createMany'
+ | 'createManyAndReturn'
+ | 'update'
+ | 'updateMany'
+ | 'updateManyAndReturn'
+ | 'upsert'
+ | 'delete'
+ | 'deleteMany'
+ | 'executeRaw'
+ | 'queryRaw'
+ | 'aggregate'
+ | 'count'
+ | 'runCommandRaw'
+ | 'findRaw'
+ | 'groupBy'
+
+ /**
+ * These options are being passed into the middleware as "params"
+ */
+ export type MiddlewareParams = {
+ model?: ModelName
+ action: PrismaAction
+ args: any
+ dataPath: string[]
+ runInTransaction: boolean
+ }
+
+ /**
+ * The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation
+ */
+ export type Middleware = (
+ params: MiddlewareParams,
+ next: (params: MiddlewareParams) => $Utils.JsPromise,
+ ) => $Utils.JsPromise
+
+ // tested in getLogLevel.test.ts
+ export function getLogLevel(log: Array): LogLevel | undefined;
+
+ /**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+ export type TransactionClient = Omit
+
+ export type Datasource = {
+ url?: string
+ }
+
+ /**
+ * Count Types
+ */
+
+
+
+ /**
+ * Models
+ */
+
+ /**
+ * Model application
+ */
+
+ export type AggregateApplication = {
+ _count: ApplicationCountAggregateOutputType | null
+ _avg: ApplicationAvgAggregateOutputType | null
+ _sum: ApplicationSumAggregateOutputType | null
+ _min: ApplicationMinAggregateOutputType | null
+ _max: ApplicationMaxAggregateOutputType | null
+ }
+
+ export type ApplicationAvgAggregateOutputType = {
+ id: number | null
+ }
+
+ export type ApplicationSumAggregateOutputType = {
+ id: number | null
+ }
+
+ export type ApplicationMinAggregateOutputType = {
+ id: number | null
+ name: string | null
+ description: string | null
+ icon: string | null
+ publicURL: string | null
+ localURL: string | null
+ }
+
+ export type ApplicationMaxAggregateOutputType = {
+ id: number | null
+ name: string | null
+ description: string | null
+ icon: string | null
+ publicURL: string | null
+ localURL: string | null
+ }
+
+ export type ApplicationCountAggregateOutputType = {
+ id: number
+ name: number
+ description: number
+ icon: number
+ publicURL: number
+ localURL: number
+ _all: number
+ }
+
+
+ export type ApplicationAvgAggregateInputType = {
+ id?: true
+ }
+
+ export type ApplicationSumAggregateInputType = {
+ id?: true
+ }
+
+ export type ApplicationMinAggregateInputType = {
+ id?: true
+ name?: true
+ description?: true
+ icon?: true
+ publicURL?: true
+ localURL?: true
+ }
+
+ export type ApplicationMaxAggregateInputType = {
+ id?: true
+ name?: true
+ description?: true
+ icon?: true
+ publicURL?: true
+ localURL?: true
+ }
+
+ export type ApplicationCountAggregateInputType = {
+ id?: true
+ name?: true
+ description?: true
+ icon?: true
+ publicURL?: true
+ localURL?: true
+ _all?: true
+ }
+
+ export type ApplicationAggregateArgs = {
+ /**
+ * Filter which application to aggregate.
+ */
+ where?: applicationWhereInput
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+ *
+ * Determine the order of applications to fetch.
+ */
+ orderBy?: applicationOrderByWithRelationInput | applicationOrderByWithRelationInput[]
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+ *
+ * Sets the start position
+ */
+ cursor?: applicationWhereUniqueInput
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+ *
+ * Take `±n` applications 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` applications.
+ */
+ skip?: number
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+ *
+ * Count returned applications
+ **/
+ _count?: true | ApplicationCountAggregateInputType
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+ *
+ * Select which fields to average
+ **/
+ _avg?: ApplicationAvgAggregateInputType
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+ *
+ * Select which fields to sum
+ **/
+ _sum?: ApplicationSumAggregateInputType
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+ *
+ * Select which fields to find the minimum value
+ **/
+ _min?: ApplicationMinAggregateInputType
+ /**
+ * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+ *
+ * Select which fields to find the maximum value
+ **/
+ _max?: ApplicationMaxAggregateInputType
+ }
+
+ export type GetApplicationAggregateType = {
+ [P in keyof T & keyof AggregateApplication]: P extends '_count' | 'count'
+ ? T[P] extends true
+ ? number
+ : GetScalarType
+ : GetScalarType
+ }
+
+
+
+
+ export type applicationGroupByArgs = {
+ where?: applicationWhereInput
+ orderBy?: applicationOrderByWithAggregationInput | applicationOrderByWithAggregationInput[]
+ by: ApplicationScalarFieldEnum[] | ApplicationScalarFieldEnum
+ having?: applicationScalarWhereWithAggregatesInput
+ take?: number
+ skip?: number
+ _count?: ApplicationCountAggregateInputType | true
+ _avg?: ApplicationAvgAggregateInputType
+ _sum?: ApplicationSumAggregateInputType
+ _min?: ApplicationMinAggregateInputType
+ _max?: ApplicationMaxAggregateInputType
+ }
+
+ export type ApplicationGroupByOutputType = {
+ id: number
+ name: string
+ description: string | null
+ icon: string
+ publicURL: string
+ localURL: string | null
+ _count: ApplicationCountAggregateOutputType | null
+ _avg: ApplicationAvgAggregateOutputType | null
+ _sum: ApplicationSumAggregateOutputType | null
+ _min: ApplicationMinAggregateOutputType | null
+ _max: ApplicationMaxAggregateOutputType | null
+ }
+
+ type GetApplicationGroupByPayload = Prisma.PrismaPromise<
+ Array<
+ PickEnumerable &
+ {
+ [P in ((keyof T) & (keyof ApplicationGroupByOutputType))]: P extends '_count'
+ ? T[P] extends boolean
+ ? number
+ : GetScalarType
+ : GetScalarType
+ }
+ >
+ >
+
+
+ export type applicationSelect = $Extensions.GetSelect<{
+ id?: boolean
+ name?: boolean
+ description?: boolean
+ icon?: boolean
+ publicURL?: boolean
+ localURL?: boolean
+ }, ExtArgs["result"]["application"]>
+
+ export type applicationSelectCreateManyAndReturn = $Extensions.GetSelect<{
+ id?: boolean
+ name?: boolean
+ description?: boolean
+ icon?: boolean
+ publicURL?: boolean
+ localURL?: boolean
+ }, ExtArgs["result"]["application"]>
+
+ export type applicationSelectUpdateManyAndReturn = $Extensions.GetSelect<{
+ id?: boolean
+ name?: boolean
+ description?: boolean
+ icon?: boolean
+ publicURL?: boolean
+ localURL?: boolean
+ }, ExtArgs["result"]["application"]>
+
+ export type applicationSelectScalar = {
+ id?: boolean
+ name?: boolean
+ description?: boolean
+ icon?: boolean
+ publicURL?: boolean
+ localURL?: boolean
+ }
+
+ export type applicationOmit = $Extensions.GetOmit<"id" | "name" | "description" | "icon" | "publicURL" | "localURL", ExtArgs["result"]["application"]>
+
+ export type $applicationPayload = {
+ name: "application"
+ objects: {}
+ scalars: $Extensions.GetPayloadResult<{
+ id: number
+ name: string
+ description: string | null
+ icon: string
+ publicURL: string
+ localURL: string | null
+ }, ExtArgs["result"]["application"]>
+ composites: {}
+ }
+
+ type applicationGetPayload = $Result.GetResult
+
+ type applicationCountArgs =
+ Omit & {
+ select?: ApplicationCountAggregateInputType | true
+ }
+
+ export interface applicationDelegate {
+ [K: symbol]: { types: Prisma.TypeMap['model']['application'], meta: { name: 'application' } }
+ /**
+ * Find zero or one Application that matches the filter.
+ * @param {applicationFindUniqueArgs} args - Arguments to find a Application
+ * @example
+ * // Get one Application
+ * const application = await prisma.application.findUnique({
+ * where: {
+ * // ... provide filter here
+ * }
+ * })
+ */
+ findUnique(args: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Find one Application that matches the filter or throw an error with `error.code='P2025'`
+ * if no matches were found.
+ * @param {applicationFindUniqueOrThrowArgs} args - Arguments to find a Application
+ * @example
+ * // Get one Application
+ * const application = await prisma.application.findUniqueOrThrow({
+ * where: {
+ * // ... provide filter here
+ * }
+ * })
+ */
+ findUniqueOrThrow(args: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Find the first Application 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 {applicationFindFirstArgs} args - Arguments to find a Application
+ * @example
+ * // Get one Application
+ * const application = await prisma.application.findFirst({
+ * where: {
+ * // ... provide filter here
+ * }
+ * })
+ */
+ findFirst(args?: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Find the first Application 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 {applicationFindFirstOrThrowArgs} args - Arguments to find a Application
+ * @example
+ * // Get one Application
+ * const application = await prisma.application.findFirstOrThrow({
+ * where: {
+ * // ... provide filter here
+ * }
+ * })
+ */
+ findFirstOrThrow(args?: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Find zero or more Applications 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 {applicationFindManyArgs} args - Arguments to filter and select certain fields only.
+ * @example
+ * // Get all Applications
+ * const applications = await prisma.application.findMany()
+ *
+ * // Get first 10 Applications
+ * const applications = await prisma.application.findMany({ take: 10 })
+ *
+ * // Only select the `id`
+ * const applicationWithIdOnly = await prisma.application.findMany({ select: { id: true } })
+ *
+ */
+ findMany(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "findMany", GlobalOmitOptions>>
+
+ /**
+ * Create a Application.
+ * @param {applicationCreateArgs} args - Arguments to create a Application.
+ * @example
+ * // Create one Application
+ * const Application = await prisma.application.create({
+ * data: {
+ * // ... data to create a Application
+ * }
+ * })
+ *
+ */
+ create(args: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Create many Applications.
+ * @param {applicationCreateManyArgs} args - Arguments to create many Applications.
+ * @example
+ * // Create many Applications
+ * const application = await prisma.application.createMany({
+ * data: [
+ * // ... provide data here
+ * ]
+ * })
+ *
+ */
+ createMany(args?: SelectSubset>): Prisma.PrismaPromise
+
+ /**
+ * Create many Applications and returns the data saved in the database.
+ * @param {applicationCreateManyAndReturnArgs} args - Arguments to create many Applications.
+ * @example
+ * // Create many Applications
+ * const application = await prisma.application.createManyAndReturn({
+ * data: [
+ * // ... provide data here
+ * ]
+ * })
+ *
+ * // Create many Applications and only return the `id`
+ * const applicationWithIdOnly = await prisma.application.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(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "createManyAndReturn", GlobalOmitOptions>>
+
+ /**
+ * Delete a Application.
+ * @param {applicationDeleteArgs} args - Arguments to delete one Application.
+ * @example
+ * // Delete one Application
+ * const Application = await prisma.application.delete({
+ * where: {
+ * // ... filter to delete one Application
+ * }
+ * })
+ *
+ */
+ delete(args: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Update one Application.
+ * @param {applicationUpdateArgs} args - Arguments to update one Application.
+ * @example
+ * // Update one Application
+ * const application = await prisma.application.update({
+ * where: {
+ * // ... provide filter here
+ * },
+ * data: {
+ * // ... provide data here
+ * }
+ * })
+ *
+ */
+ update(args: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+ /**
+ * Delete zero or more Applications.
+ * @param {applicationDeleteManyArgs} args - Arguments to filter Applications to delete.
+ * @example
+ * // Delete a few Applications
+ * const { count } = await prisma.application.deleteMany({
+ * where: {
+ * // ... provide filter here
+ * }
+ * })
+ *
+ */
+ deleteMany(args?: SelectSubset>): Prisma.PrismaPromise
+
+ /**
+ * Update zero or more Applications.
+ * Note, that providing `undefined` is treated as the value not being there.
+ * Read more here: https://pris.ly/d/null-undefined
+ * @param {applicationUpdateManyArgs} args - Arguments to update one or more rows.
+ * @example
+ * // Update many Applications
+ * const application = await prisma.application.updateMany({
+ * where: {
+ * // ... provide filter here
+ * },
+ * data: {
+ * // ... provide data here
+ * }
+ * })
+ *
+ */
+ updateMany(args: SelectSubset>): Prisma.PrismaPromise
+
+ /**
+ * Update zero or more Applications and returns the data updated in the database.
+ * @param {applicationUpdateManyAndReturnArgs} args - Arguments to update many Applications.
+ * @example
+ * // Update many Applications
+ * const application = await prisma.application.updateManyAndReturn({
+ * where: {
+ * // ... provide filter here
+ * },
+ * data: [
+ * // ... provide data here
+ * ]
+ * })
+ *
+ * // Update zero or more Applications and only return the `id`
+ * const applicationWithIdOnly = await prisma.application.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
+ *
+ */
+ updateManyAndReturn(args: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+ /**
+ * Create or update one Application.
+ * @param {applicationUpsertArgs} args - Arguments to update or create a Application.
+ * @example
+ * // Update or create a Application
+ * const application = await prisma.application.upsert({
+ * create: {
+ * // ... data to create a Application
+ * },
+ * update: {
+ * // ... in case it already exists, update
+ * },
+ * where: {
+ * // ... the filter for the Application we want to update
+ * }
+ * })
+ */
+ upsert(args: SelectSubset>): Prisma__applicationClient<$Result.GetResult, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+ /**
+ * Count the number of Applications.
+ * Note, that providing `undefined` is treated as the value not being there.
+ * Read more here: https://pris.ly/d/null-undefined
+ * @param {applicationCountArgs} args - Arguments to filter Applications to count.
+ * @example
+ * // Count the number of Applications
+ * const count = await prisma.application.count({
+ * where: {
+ * // ... the filter for the Applications we want to count
+ * }
+ * })
+ **/
+ count(
+ args?: Subset,
+ ): Prisma.PrismaPromise<
+ T extends $Utils.Record<'select', any>
+ ? T['select'] extends true
+ ? number
+ : GetScalarType
+ : number
+ >
+
+ /**
+ * Allows you to perform aggregations operations on a Application.
+ * Note, that providing `undefined` is treated as the value not being there.
+ * Read more here: https://pris.ly/d/null-undefined
+ * @param {ApplicationAggregateArgs} 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(args: Subset): Prisma.PrismaPromise>
+
+ /**
+ * Group by Application.
+ * Note, that providing `undefined` is treated as the value not being there.
+ * Read more here: https://pris.ly/d/null-undefined
+ * @param {applicationGroupByArgs} 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 applicationGroupByArgs,
+ HasSelectOrTake extends Or<
+ Extends<'skip', Keys>,
+ Extends<'take', Keys>
+ >,
+ OrderByArg extends True extends HasSelectOrTake
+ ? { orderBy: applicationGroupByArgs['orderBy'] }
+ : { orderBy?: applicationGroupByArgs['orderBy'] },
+ OrderFields extends ExcludeUnderscoreKeys>>,
+ ByFields extends MaybeTupleToUnion,
+ ByValid extends Has,
+ HavingFields extends GetHavingFields,
+ HavingValid extends Has,
+ 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
+ ? 'orderBy' extends Keys
+ ? 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
+ ? 'orderBy' extends Keys
+ ? 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 & InputErrors): {} extends InputErrors ? GetApplicationGroupByPayload : Prisma.PrismaPromise
+ /**
+ * Fields of the application model
+ */
+ readonly fields: applicationFieldRefs;
+ }
+
+ /**
+ * The delegate class that acts as a "Promise-like" for application.
+ * 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__applicationClient extends Prisma.PrismaPromise {
+ readonly [Symbol.toStringTag]: "PrismaPromise"
+ /**
+ * 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(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): $Utils.JsPromise
+ /**
+ * 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(onrejected?: ((reason: any) => TResult | PromiseLike