;
+
+ /**
+ * 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<
+ Prisma.TypeMapCb,
+ {
+ extArgs: ExtArgs;
+ }
+ >
+ >;
+
+ /**
+ * `prisma.user`: Exposes CRUD operations for the **User** model.
+ * Example usage:
+ * ```ts
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ */
+ get user(): Prisma.UserDelegate;
+
+ /**
+ * `prisma.post`: Exposes CRUD operations for the **Post** model.
+ * Example usage:
+ * ```ts
+ * // Fetch zero or more Posts
+ * const posts = await prisma.post.findMany()
+ * ```
+ */
+ get post(): Prisma.PostDelegate;
+
+ /**
+ * `prisma.company`: Exposes CRUD operations for the **Company** model.
+ * Example usage:
+ * ```ts
+ * // Fetch zero or more Companies
+ * const companies = await prisma.company.findMany()
+ * ```
+ */
+ get company(): Prisma.CompanyDelegate;
+
+ /**
+ * `prisma.team`: Exposes CRUD operations for the **Team** model.
+ * Example usage:
+ * ```ts
+ * // Fetch zero or more Teams
+ * const teams = await prisma.team.findMany()
+ * ```
+ */
+ get team(): Prisma.TeamDelegate;
+
+ /**
+ * `prisma.onboarding`: Exposes CRUD operations for the **Onboarding** model.
+ * Example usage:
+ * ```ts
+ * // Fetch zero or more Onboardings
+ * const onboardings = await prisma.onboarding.findMany()
+ * ```
+ */
+ get onboarding(): Prisma.OnboardingDelegate;
+}
+
+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.12.0
+ * Query Engine version: 8047c96bbd92db98a2abc7c9323ce77c02c89dbc
+ */
+ 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<
+ ReturnType
+ >;
+
+ /**
+ * 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 = {
+ 1: EitherStrict;
+ 0: EitherLoose;
+ }[strict];
+
+ type Either = 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<
+ Overwrite<
+ U,
+ {
+ [K in keyof U]-?: At;
+ }
+ >
+ >;
+
+ 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, 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> =
+ IsObject extends True ? U : T;
+
+ type GetHavingFields = {
+ [K in keyof T]: 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<
+ T,
+ MaybeTupleToUnion
+ >;
+
+ /**
+ * 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: {
+ User: 'User';
+ Post: 'Post';
+ Company: 'Company';
+ Team: 'Team';
+ Onboarding: 'Onboarding';
+ };
+
+ 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<
+ this['params']['extArgs'],
+ ClientOptions extends { omit: infer OmitOptions } ? OmitOptions : {}
+ >;
+ }
+
+ export type TypeMap<
+ ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs,
+ GlobalOmitOptions = {},
+ > = {
+ globalOmitOptions: {
+ omit: GlobalOmitOptions;
+ };
+ meta: {
+ modelProps: 'user' | 'post' | 'company' | 'team' | 'onboarding';
+ txIsolationLevel: Prisma.TransactionIsolationLevel;
+ };
+ model: {
+ User: {
+ payload: Prisma.$UserPayload;
+ fields: Prisma.UserFieldRefs;
+ operations: {
+ findUnique: {
+ args: Prisma.UserFindUniqueArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findUniqueOrThrow: {
+ args: Prisma.UserFindUniqueOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findFirst: {
+ args: Prisma.UserFindFirstArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findFirstOrThrow: {
+ args: Prisma.UserFindFirstOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findMany: {
+ args: Prisma.UserFindManyArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ create: {
+ args: Prisma.UserCreateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ createMany: {
+ args: Prisma.UserCreateManyArgs;
+ result: BatchPayload;
+ };
+ createManyAndReturn: {
+ args: Prisma.UserCreateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ delete: {
+ args: Prisma.UserDeleteArgs;
+ result: $Utils.PayloadToResult;
+ };
+ update: {
+ args: Prisma.UserUpdateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ deleteMany: {
+ args: Prisma.UserDeleteManyArgs;
+ result: BatchPayload;
+ };
+ updateMany: {
+ args: Prisma.UserUpdateManyArgs;
+ result: BatchPayload;
+ };
+ updateManyAndReturn: {
+ args: Prisma.UserUpdateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ upsert: {
+ args: Prisma.UserUpsertArgs;
+ result: $Utils.PayloadToResult;
+ };
+ aggregate: {
+ args: Prisma.UserAggregateArgs;
+ result: $Utils.Optional;
+ };
+ groupBy: {
+ args: Prisma.UserGroupByArgs;
+ result: $Utils.Optional[];
+ };
+ count: {
+ args: Prisma.UserCountArgs;
+ result: $Utils.Optional | number;
+ };
+ };
+ };
+ Post: {
+ payload: Prisma.$PostPayload;
+ fields: Prisma.PostFieldRefs;
+ operations: {
+ findUnique: {
+ args: Prisma.PostFindUniqueArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findUniqueOrThrow: {
+ args: Prisma.PostFindUniqueOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findFirst: {
+ args: Prisma.PostFindFirstArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findFirstOrThrow: {
+ args: Prisma.PostFindFirstOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findMany: {
+ args: Prisma.PostFindManyArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ create: {
+ args: Prisma.PostCreateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ createMany: {
+ args: Prisma.PostCreateManyArgs;
+ result: BatchPayload;
+ };
+ createManyAndReturn: {
+ args: Prisma.PostCreateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ delete: {
+ args: Prisma.PostDeleteArgs;
+ result: $Utils.PayloadToResult;
+ };
+ update: {
+ args: Prisma.PostUpdateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ deleteMany: {
+ args: Prisma.PostDeleteManyArgs;
+ result: BatchPayload;
+ };
+ updateMany: {
+ args: Prisma.PostUpdateManyArgs;
+ result: BatchPayload;
+ };
+ updateManyAndReturn: {
+ args: Prisma.PostUpdateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ upsert: {
+ args: Prisma.PostUpsertArgs;
+ result: $Utils.PayloadToResult;
+ };
+ aggregate: {
+ args: Prisma.PostAggregateArgs;
+ result: $Utils.Optional;
+ };
+ groupBy: {
+ args: Prisma.PostGroupByArgs;
+ result: $Utils.Optional[];
+ };
+ count: {
+ args: Prisma.PostCountArgs;
+ result: $Utils.Optional | number;
+ };
+ };
+ };
+ Company: {
+ payload: Prisma.$CompanyPayload;
+ fields: Prisma.CompanyFieldRefs;
+ operations: {
+ findUnique: {
+ args: Prisma.CompanyFindUniqueArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findUniqueOrThrow: {
+ args: Prisma.CompanyFindUniqueOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findFirst: {
+ args: Prisma.CompanyFindFirstArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findFirstOrThrow: {
+ args: Prisma.CompanyFindFirstOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findMany: {
+ args: Prisma.CompanyFindManyArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ create: {
+ args: Prisma.CompanyCreateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ createMany: {
+ args: Prisma.CompanyCreateManyArgs;
+ result: BatchPayload;
+ };
+ createManyAndReturn: {
+ args: Prisma.CompanyCreateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ delete: {
+ args: Prisma.CompanyDeleteArgs;
+ result: $Utils.PayloadToResult;
+ };
+ update: {
+ args: Prisma.CompanyUpdateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ deleteMany: {
+ args: Prisma.CompanyDeleteManyArgs;
+ result: BatchPayload;
+ };
+ updateMany: {
+ args: Prisma.CompanyUpdateManyArgs;
+ result: BatchPayload;
+ };
+ updateManyAndReturn: {
+ args: Prisma.CompanyUpdateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ upsert: {
+ args: Prisma.CompanyUpsertArgs;
+ result: $Utils.PayloadToResult;
+ };
+ aggregate: {
+ args: Prisma.CompanyAggregateArgs;
+ result: $Utils.Optional;
+ };
+ groupBy: {
+ args: Prisma.CompanyGroupByArgs;
+ result: $Utils.Optional[];
+ };
+ count: {
+ args: Prisma.CompanyCountArgs;
+ result: $Utils.Optional | number;
+ };
+ };
+ };
+ Team: {
+ payload: Prisma.$TeamPayload;
+ fields: Prisma.TeamFieldRefs;
+ operations: {
+ findUnique: {
+ args: Prisma.TeamFindUniqueArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findUniqueOrThrow: {
+ args: Prisma.TeamFindUniqueOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findFirst: {
+ args: Prisma.TeamFindFirstArgs;
+ result: $Utils.PayloadToResult | null;
+ };
+ findFirstOrThrow: {
+ args: Prisma.TeamFindFirstOrThrowArgs;
+ result: $Utils.PayloadToResult;
+ };
+ findMany: {
+ args: Prisma.TeamFindManyArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ create: {
+ args: Prisma.TeamCreateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ createMany: {
+ args: Prisma.TeamCreateManyArgs;
+ result: BatchPayload;
+ };
+ createManyAndReturn: {
+ args: Prisma.TeamCreateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ delete: {
+ args: Prisma.TeamDeleteArgs;
+ result: $Utils.PayloadToResult;
+ };
+ update: {
+ args: Prisma.TeamUpdateArgs;
+ result: $Utils.PayloadToResult;
+ };
+ deleteMany: {
+ args: Prisma.TeamDeleteManyArgs;
+ result: BatchPayload;
+ };
+ updateMany: {
+ args: Prisma.TeamUpdateManyArgs;
+ result: BatchPayload;
+ };
+ updateManyAndReturn: {
+ args: Prisma.TeamUpdateManyAndReturnArgs;
+ result: $Utils.PayloadToResult[];
+ };
+ upsert: {
+ args: Prisma.TeamUpsertArgs;
+ result: $Utils.PayloadToResult;
+ };
+ aggregate: {
+ args: Prisma.TeamAggregateArgs;
+ result: $Utils.Optional;
+ };
+ groupBy: {
+ args: Prisma.TeamGroupByArgs;
+ result: $Utils.Optional