test.ts.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`exhaustive-schema: generatedBrowserJS 1`] = `

Object.defineProperty(exports, "__esModule", { value: true });

const {
  Decimal
} = require('@prisma/client/runtime/index-browser')


const Prisma = {}

exports.Prisma = Prisma

/**
 * Prisma Client JS version: local
 * Query Engine version: local
 */
Prisma.prismaVersion = {
  client: "local",
  engine: "local"
}

Prisma.PrismaClientKnownRequestError = () => {
  throw new Error(\`PrismaClientKnownRequestError is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)};
Prisma.PrismaClientUnknownRequestError = () => {
  throw new Error(\`PrismaClientUnknownRequestError is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.PrismaClientRustPanicError = () => {
  throw new Error(\`PrismaClientRustPanicError is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.PrismaClientInitializationError = () => {
  throw new Error(\`PrismaClientInitializationError is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.PrismaClientValidationError = () => {
  throw new Error(\`PrismaClientValidationError is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.Decimal = Decimal

/**
 * Re-export of sql-template-tag
 */

Prisma.sql = () => {
  throw new Error(\`sqltag is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.empty = () => {
  throw new Error(\`empty is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.join = () => {
  throw new Error(\`join is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}
Prisma.raw = () => {
  throw new Error(\`raw is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues\`,
)}

/**
 * Enums
 */
// Based on
// https://github.com/microsoft/TypeScript/issues/3192#issuecomment-261720275
function makeEnum(x) { return x; }

exports.Prisma.PostScalarFieldEnum = makeEnum({
  id: 'id',
  createdAt: 'createdAt',
  title: 'title',
  content: 'content',
  published: 'published',
  authorId: 'authorId'
});

exports.Prisma.UserScalarFieldEnum = makeEnum({
  id: 'id',
  email: 'email',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.MScalarFieldEnum = makeEnum({
  id: 'id',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.NScalarFieldEnum = makeEnum({
  id: 'id',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.OneOptionalScalarFieldEnum = makeEnum({
  id: 'id',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.ManyRequiredScalarFieldEnum = makeEnum({
  id: 'id',
  oneOptionalId: 'oneOptionalId',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.OptionalSide1ScalarFieldEnum = makeEnum({
  id: 'id',
  optionalSide2Id: 'optionalSide2Id',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.OptionalSide2ScalarFieldEnum = makeEnum({
  id: 'id',
  int: 'int',
  optionalInt: 'optionalInt',
  float: 'float',
  optionalFloat: 'optionalFloat',
  string: 'string',
  optionalString: 'optionalString',
  json: 'json',
  optionalJson: 'optionalJson',
  enum: 'enum',
  optionalEnum: 'optionalEnum',
  boolean: 'boolean',
  optionalBoolean: 'optionalBoolean'
});

exports.Prisma.AScalarFieldEnum = makeEnum({
  id: 'id',
  email: 'email',
  name: 'name',
  int: 'int',
  sInt: 'sInt',
  bInt: 'bInt',
  serial: 'serial',
  sSerial: 'sSerial',
  bSerial: 'bSerial',
  inc_int: 'inc_int',
  inc_sInt: 'inc_sInt',
  inc_bInt: 'inc_bInt'
});

exports.Prisma.BScalarFieldEnum = makeEnum({
  id: 'id',
  float: 'float',
  dFloat: 'dFloat',
  decFloat: 'decFloat',
  numFloat: 'numFloat'
});

exports.Prisma.CScalarFieldEnum = makeEnum({
  id: 'id',
  char: 'char',
  vChar: 'vChar',
  text: 'text',
  bit: 'bit',
  vBit: 'vBit',
  uuid: 'uuid'
});

exports.Prisma.DScalarFieldEnum = makeEnum({
  id: 'id',
  bool: 'bool',
  byteA: 'byteA',
  xml: 'xml',
  json: 'json',
  jsonb: 'jsonb'
});

exports.Prisma.EScalarFieldEnum = makeEnum({
  id: 'id',
  date: 'date',
  time: 'time',
  ts: 'ts'
});

exports.Prisma.SortOrder = makeEnum({
  asc: 'asc',
  desc: 'desc'
});

exports.Prisma.QueryMode = makeEnum({
  default: 'default',
  insensitive: 'insensitive'
});
exports.ABeautifulEnum = makeEnum({
  A: 'A',
  B: 'B',
  C: 'C'
});

exports.Prisma.ModelName = makeEnum({
  Post: 'Post',
  User: 'User',
  M: 'M',
  N: 'N',
  OneOptional: 'OneOptional',
  ManyRequired: 'ManyRequired',
  OptionalSide1: 'OptionalSide1',
  OptionalSide2: 'OptionalSide2',
  A: 'A',
  B: 'B',
  C: 'C',
  D: 'D',
  E: 'E'
});

/**
 * Create the Client
 */
class PrismaClient {
  constructor() {
    throw new Error(
      \`PrismaClient is unable to be run in the browser.
In case this error is unexpected for you, please report it in https://github.com/prisma/prisma-client-js/issues\`,
    )
  }
}
exports.PrismaClient = PrismaClient

Object.assign(exports, Prisma)

`;

exports[`exhaustive-schema: generatedTypeScript 1`] = `

/**
 * Client
**/

import * as runtime from '@prisma/client/runtime';

export import DMMF = runtime.DMMF

/**
 * 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

/**
 * Prisma Client JS version: local
 * Query Engine version: local
 */
export type PrismaVersion = {
  client: string
}

export const prismaVersion: PrismaVersion 

/**
 * Utility Types
 */

/**
 * From https://github.com/sindresorhus/type-fest/
 * Matches a JSON object.
 * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. 
 */
export type JsonObject = {[Key in string]?: JsonValue}
 
/**
 * From https://github.com/sindresorhus/type-fest/
 * Matches a JSON array.
 */
export interface JsonArray extends Array<JsonValue> {}
 
/**
 * From https://github.com/sindresorhus/type-fest/
 * Matches any valid JSON value.
 */
export type JsonValue = string | number | boolean | null | JsonObject | JsonArray

/**
 * Same as JsonObject, but allows undefined
 */
export type InputJsonObject = {[Key in string]?: JsonValue}
 
export interface InputJsonArray extends Array<JsonValue> {}
 
export type InputJsonValue = undefined |  string | number | boolean | null | InputJsonObject | InputJsonArray
 type SelectAndInclude = {
  select: any
  include: any
}
type HasSelect = {
  select: any
}
type HasInclude = {
  include: any
}
type CheckSelect<T, S, U> = T extends SelectAndInclude
  ? 'Please either choose \`select\` or \`include\`'
  : T extends HasSelect
  ? U
  : T extends HasInclude
  ? U
  : S

/**
 * Get the type of the value, that the Promise holds.
 */
export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;

/**
 * Get the return type of a function which returns a Promise.
 */
export type PromiseReturnType<T extends (...args: any) => Promise<any>> = PromiseType<ReturnType<T>>


export type Enumerable<T> = T | Array<T>;

export type RequiredKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
}[keyof T]

export type TruthyKeys<T> = {
  [key in keyof T]: T[key] extends false | undefined | null ? never : key
}[keyof T]

export type TrueKeys<T> = TruthyKeys<Pick<T, RequiredKeys<T>>>

/**
 * Subset
 * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection
 */
export type Subset<T, U> = {
  [key in keyof T]: key extends keyof U ? T[key] : never;
};

/**
 * Subset + Intersection
 * @desc From \`T\` pick properties that exist in \`U\` and intersect \`K\`
 */
export type SubsetIntersection<T, U, K> = {
  [key in keyof T]: key extends keyof U ? T[key] : never
} &
  K

type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: 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, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;



/**
 * From ts-toolbelt
 */

export type Union = any
export type IntersectOf<U extends Union> = (
  U extends unknown ? (k: U) => void : never
) extends (k: infer I) => void
  ? I
  : never

/**
A [[Boolean]]
*/
export type Boolean = True | False

// /**
// 1
// */
export type True = 1

/**
0
*/
export type False = 0

export type Not<B extends Boolean> = {
  0: 1
  1: 0
}[B]

export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
  ? 0 // anything \`never\` is false
  : A1 extends A2
  ? 1
  : 0

export type Has<U extends Union, U1 extends Union> = Not<
  Extends<Exclude<U1, U>, U1>
>

export type Or<B1 extends Boolean, B2 extends Boolean> = {
  0: {
    0: 0
    1: 1
  }
  1: {
    0: 1
    1: 1
  }
}[B1][B2]

export type Keys<U extends Union> = U extends unknown ? keyof U : never

/**
 * Used by group by
 */
export type GetScalarType<T, O> = O extends object ? {
  [P in keyof T]: P extends keyof O
    ? O[P]
    : never
} : never

/**
 * Convert tuple to union
 */
type _TupleToUnion<T> = T extends (infer E)[] ? E : never
type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T

/**
 * Like \`Pick\`, but with an array
 */
type PickArray<T, K extends Array<keyof T>> = Pick<T, TupleToUnion<K>>





/**
 * Model Post
 */

export type Post = {
  id: number
  createdAt: Date
  title: string
  content: string | null
  published: boolean
  authorId: number
}

/**
 * Model User
 */

export type User = {
  id: number
  email: string
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model M
 */

export type M = {
  id: number
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model N
 */

export type N = {
  id: number
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model OneOptional
 */

export type OneOptional = {
  id: number
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model ManyRequired
 */

export type ManyRequired = {
  id: number
  oneOptionalId: number | null
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model OptionalSide1
 */

export type OptionalSide1 = {
  id: number
  optionalSide2Id: number | null
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model OptionalSide2
 */

export type OptionalSide2 = {
  id: number
  int: number
  optionalInt: number | null
  float: number
  optionalFloat: number | null
  string: string
  optionalString: string | null
  json: Prisma.JsonValue
  optionalJson: Prisma.JsonValue | null
  enum: ABeautifulEnum
  optionalEnum: ABeautifulEnum | null
  boolean: boolean
  optionalBoolean: boolean | null
}

/**
 * Model A
 */

export type A = {
  id: string
  email: string
  name: string | null
  int: number
  sInt: number
  bInt: BigInt
  serial: number
  sSerial: number
  bSerial: number
  inc_int: number
  inc_sInt: number
  inc_bInt: BigInt
}

/**
 * Model B
 */

export type B = {
  id: string
  float: number
  dFloat: number
  decFloat: Prisma.Decimal
  numFloat: Prisma.Decimal
}

/**
 * Model C
 */

export type C = {
  id: string
  char: string
  vChar: string
  text: string
  bit: string
  vBit: string
  uuid: string
}

/**
 * Model D
 */

export type D = {
  id: string
  bool: boolean
  byteA: Buffer
  xml: string
  json: Prisma.JsonValue
  jsonb: Prisma.JsonValue
}

/**
 * Model E
 */

export type E = {
  id: string
  date: Date
  time: Date
  ts: Date
}


/**
 * Enums
 */

// Based on
// https://github.com/microsoft/TypeScript/issues/3192#issuecomment-261720275

export const ABeautifulEnum: {
  A: 'A',
  B: 'B',
  C: 'C'
};

export type ABeautifulEnum = (typeof ABeautifulEnum)[keyof typeof ABeautifulEnum]


/**
 * ##  Prisma Client ʲˢ
 * 
 * Type-safe database client for TypeScript & Node.js (ORM replacement)
 * @example
 * \`\`\`
 * const prisma = new PrismaClient()
 * // Fetch zero or more Posts
 * const posts = await prisma.post.findMany()
 * \`\`\`
 *
 * 
 * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
 */
export class PrismaClient<
  T extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  U = 'log' extends keyof T ? T['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<T['log']> : never : never
      > {
      /**
       * @private
       */
      private fetcher;
      /**
       * @private
       */
      private readonly dmmf;
      /**
       * @private
       */
      private connectionPromise?;
      /**
       * @private
       */
      private disconnectionPromise?;
      /**
       * @private
       */
      private readonly engineConfig;
      /**
       * @private
       */
      private readonly measurePerformance;

    /**
   * ##  Prisma Client ʲˢ
   * 
   * Type-safe database client for TypeScript & Node.js (ORM replacement)
   * @example
   * \`\`\`
   * const prisma = new PrismaClient()
   * // Fetch zero or more Posts
   * const posts = await prisma.post.findMany()
   * \`\`\`
   *
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
   */

  constructor(optionsArg ?: T);
  $on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void;

  /**
   * Connect with the database
   */
  $connect(): Promise<void>;

  /**
   * Disconnect from the database
   */
  $disconnect(): Promise<any>;

  /**
   * Add a middleware
   */
  $use(cb: Prisma.Middleware): void

  /**
   * Executes a raw query and returns the number of affected rows
   * @example
   * \`\`\`
   * // With parameters use prisma.executeRaw\`\`, values will be escaped automatically
   * const result = await prisma.executeRaw\`UPDATE User SET cool = \${true} WHERE id = \${1};\`
   * // Or
   * const result = await prisma.executeRaw('UPDATE User SET cool = $1 WHERE id = $2 ;', true, 1)
  * \`\`\`
  * 
  * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
  */
  $executeRaw < T = any > (query: string | TemplateStringsArray | Prisma.Sql, ...values: any[]): Promise<number>;

  /**
   * Performs a raw query and returns the SELECT data
   * @example
   * \`\`\`
   * // With parameters use prisma.queryRaw\`\`, values will be escaped automatically
   * const result = await prisma.queryRaw\`SELECT * FROM User WHERE id = \${1} OR email = \${'ema.il'};\`
   * // Or
   * const result = await prisma.queryRaw('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'ema.il')
  * \`\`\`
  * 
  * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
  */
  $queryRaw < T = any > (query: string | TemplateStringsArray | Prisma.Sql, ...values: any[]): Promise<T>;

  /**
   * Execute queries in a transaction
   * @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' } }),
   * ])
   * \`\`\`
   */
  $transaction: PromiseConstructor['all']

      /**
   * \`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.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.m\`: Exposes CRUD operations for the **M** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more Ms
    * const ms = await prisma.m.findMany()
    * \`\`\`
    */
  get m(): Prisma.MDelegate;

  /**
   * \`prisma.n\`: Exposes CRUD operations for the **N** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more Ns
    * const ns = await prisma.n.findMany()
    * \`\`\`
    */
  get n(): Prisma.NDelegate;

  /**
   * \`prisma.oneOptional\`: Exposes CRUD operations for the **OneOptional** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more OneOptionals
    * const oneOptionals = await prisma.oneOptional.findMany()
    * \`\`\`
    */
  get oneOptional(): Prisma.OneOptionalDelegate;

  /**
   * \`prisma.manyRequired\`: Exposes CRUD operations for the **ManyRequired** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more ManyRequireds
    * const manyRequireds = await prisma.manyRequired.findMany()
    * \`\`\`
    */
  get manyRequired(): Prisma.ManyRequiredDelegate;

  /**
   * \`prisma.optionalSide1\`: Exposes CRUD operations for the **OptionalSide1** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more OptionalSide1s
    * const optionalSide1s = await prisma.optionalSide1.findMany()
    * \`\`\`
    */
  get optionalSide1(): Prisma.OptionalSide1Delegate;

  /**
   * \`prisma.optionalSide2\`: Exposes CRUD operations for the **OptionalSide2** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more OptionalSide2s
    * const optionalSide2s = await prisma.optionalSide2.findMany()
    * \`\`\`
    */
  get optionalSide2(): Prisma.OptionalSide2Delegate;

  /**
   * \`prisma.a\`: Exposes CRUD operations for the **A** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more As
    * const as = await prisma.a.findMany()
    * \`\`\`
    */
  get a(): Prisma.ADelegate;

  /**
   * \`prisma.b\`: Exposes CRUD operations for the **B** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more Bs
    * const bs = await prisma.b.findMany()
    * \`\`\`
    */
  get b(): Prisma.BDelegate;

  /**
   * \`prisma.c\`: Exposes CRUD operations for the **C** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more Cs
    * const cs = await prisma.c.findMany()
    * \`\`\`
    */
  get c(): Prisma.CDelegate;

  /**
   * \`prisma.d\`: Exposes CRUD operations for the **D** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more Ds
    * const ds = await prisma.d.findMany()
    * \`\`\`
    */
  get d(): Prisma.DDelegate;

  /**
   * \`prisma.e\`: Exposes CRUD operations for the **E** model.
    * Example usage:
    * \`\`\`ts
    * // Fetch zero or more Es
    * const es = await prisma.e.findMany()
    * \`\`\`
    */
  get e(): Prisma.EDelegate;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

  /**
   * 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

  /**
   * Prisma Client JS version: local
   * Query Engine version: local
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches a JSON object.
   * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. 
   */
  export type JsonObject = {[Key in string]?: JsonValue}
 
  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches a JSON array.
   */
  export interface JsonArray extends Array<JsonValue> {}
 
  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches any valid JSON value.
   */
  export type JsonValue = string | number | boolean | null | JsonObject | JsonArray

  /**
   * Same as JsonObject, but allows undefined
   */
  export type InputJsonObject = {[Key in string]?: JsonValue}
 
  export interface InputJsonArray extends Array<JsonValue> {}
 
  export type InputJsonValue = undefined |  string | number | boolean | null | InputJsonObject | InputJsonArray
   type SelectAndInclude = {
    select: any
    include: any
  }
  type HasSelect = {
    select: any
  }
  type HasInclude = {
    include: any
  }
  type CheckSelect<T, S, U> = T extends SelectAndInclude
    ? 'Please either choose \`select\` or \`include\`'
    : T extends HasSelect
    ? U
    : T extends HasInclude
    ? U
    : S

  /**
   * Get the type of the value, that the Promise holds.
   */
  export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;

  /**
   * Get the return type of a function which returns a Promise.
   */
  export type PromiseReturnType<T extends (...args: any) => Promise<any>> = PromiseType<ReturnType<T>>


  export type Enumerable<T> = T | Array<T>;

  export type RequiredKeys<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? never : K
  }[keyof T]

  export type TruthyKeys<T> = {
    [key in keyof T]: T[key] extends false | undefined | null ? never : key
  }[keyof T]

  export type TrueKeys<T> = TruthyKeys<Pick<T, RequiredKeys<T>>>

  /**
   * Subset
   * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection
   */
  export type Subset<T, U> = {
    [key in keyof T]: key extends keyof U ? T[key] : never;
  };

  /**
   * Subset + Intersection
   * @desc From \`T\` pick properties that exist in \`U\` and intersect \`K\`
   */
  export type SubsetIntersection<T, U, K> = {
    [key in keyof T]: key extends keyof U ? T[key] : never
  } &
    K

  type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: 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, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;



  /**
   * From ts-toolbelt
   */

  export type Union = any
  export type IntersectOf<U extends Union> = (
    U extends unknown ? (k: U) => void : never
  ) extends (k: infer I) => void
    ? I
    : never

  /**
  A [[Boolean]]
  */
  export type Boolean = True | False

  // /**
  // 1
  // */
  export type True = 1

  /**
  0
  */
  export type False = 0

  export type Not<B extends Boolean> = {
    0: 1
    1: 0
  }[B]

  export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
    ? 0 // anything \`never\` is false
    : A1 extends A2
    ? 1
    : 0

  export type Has<U extends Union, U1 extends Union> = Not<
    Extends<Exclude<U1, U>, U1>
  >

  export type Or<B1 extends Boolean, B2 extends Boolean> = {
    0: {
      0: 0
      1: 1
    }
    1: {
      0: 1
      1: 1
    }
  }[B1][B2]

  export type Keys<U extends Union> = U extends unknown ? keyof U : never

  /**
   * Used by group by
   */
  export type GetScalarType<T, O> = O extends object ? {
    [P in keyof T]: P extends keyof O
      ? O[P]
      : never
  } : never

  /**
   * Convert tuple to union
   */
  type _TupleToUnion<T> = T extends (infer E)[] ? E : never
  type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
  type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T

  /**
   * Like \`Pick\`, but with an array
   */
  type PickArray<T, K extends Array<keyof T>> = Pick<T, TupleToUnion<K>>

  class PrismaClientFetcher {
    private readonly prisma;
    private readonly debug;
    private readonly hooks?;
    constructor(prisma: PrismaClient<any, any>, debug?: boolean, hooks?: Hooks | undefined);
    request<T>(document: any, dataPath?: string[], rootField?: string, typeName?: string, isList?: boolean, callsite?: string): Promise<T>;
    sanitizeMessage(message: string): string;
    protected unpack(document: any, data: any, path: string[], rootField?: string, isList?: boolean): any;
  }

  export const ModelName: {
    Post: 'Post',
    User: 'User',
    M: 'M',
    N: 'N',
    OneOptional: 'OneOptional',
    ManyRequired: 'ManyRequired',
    OptionalSide1: 'OptionalSide1',
    OptionalSide2: 'OptionalSide2',
    A: 'A',
    B: 'B',
    C: 'C',
    D: 'D',
    E: 'E'
  };

  export type ModelName = (typeof ModelName)[keyof typeof ModelName]


  export type Datasources = {
    db?: Datasource
  }

  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'

  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your prisma.schema file
     */
    datasources?: Datasources

    /**
     * @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?: Array<LogLevel | LogDefinition>
  }

  export type Hooks = {
    beforeRequest?: (options: { query: string, path: string[], rootField?: string, typeName?: string, document: any }) => any
  }

  /* Types for Logging */
  export type LogLevel = 'info' | 'query' | 'warn' | 'error'
  export type LogDefinition = {
    level: LogLevel
    emit: 'stdout' | 'event'
  }

  export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
  export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
    GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
    : 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'
    | 'findMany'
    | 'findFirst'
    | 'create'
    | 'update'
    | 'updateMany'
    | 'upsert'
    | 'delete'
    | 'deleteMany'
    | 'executeRaw'
    | 'queryRaw'
    | 'aggregate'
    | 'count'

  /**
   * These options are being passed in to 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<T = any> = (
    params: MiddlewareParams,
    next: (params: MiddlewareParams) => Promise<T>,
  ) => Promise<T>

  // tested in getLogLevel.test.ts
  export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined; 
  export type Datasource = {
    url?: string
  }


  /**
   * Model Post
   */


  export type AggregatePost = {
    count: number | null
    avg: PostAvgAggregateOutputType | null
    sum: PostSumAggregateOutputType | null
    min: PostMinAggregateOutputType | null
    max: PostMaxAggregateOutputType | null
  }

  export type PostAvgAggregateOutputType = {
    id: number
    authorId: number
  }

  export type PostSumAggregateOutputType = {
    id: number
    authorId: number
  }

  export type PostMinAggregateOutputType = {
    id: number
    createdAt: Date | null
    title: string | null
    content: string | null
    published: boolean | null
    authorId: number
  }

  export type PostMaxAggregateOutputType = {
    id: number
    createdAt: Date | null
    title: string | null
    content: string | null
    published: boolean | null
    authorId: number
  }

  export type PostCountAggregateOutputType = {
    id: number
    createdAt: number | null
    title: number | null
    content: number | null
    published: number | null
    authorId: number
    _all: number
  }


  export type PostAvgAggregateInputType = {
    id?: true
    authorId?: true
  }

  export type PostSumAggregateInputType = {
    id?: true
    authorId?: true
  }

  export type PostMinAggregateInputType = {
    id?: true
    createdAt?: true
    title?: true
    content?: true
    published?: true
    authorId?: true
  }

  export type PostMaxAggregateInputType = {
    id?: true
    createdAt?: true
    title?: true
    content?: true
    published?: true
    authorId?: true
  }

  export type PostCountAggregateInputType = {
    id?: true
    createdAt?: true
    title?: true
    content?: true
    published?: true
    authorId?: true
    _all?: true
  }

  export type AggregatePostArgs = {
    /**
     * Filter which Post to aggregate.
    **/
    where?: PostWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of Posts to fetch.
    **/
    orderBy?: Enumerable<PostOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: PostWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` Posts 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\` Posts.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Posts
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: PostAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: PostSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: PostMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: PostMaxAggregateInputType
  }

  export type GetPostAggregateType<T extends AggregatePostArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetPostAggregateScalarType<T[P]>
  }

  export type GetPostAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof PostAvgAggregateOutputType ? PostAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByPostArgs = {
    where?: PostWhereInput
    orderBy?: Enumerable<PostOrderByInput>
    by: Array<PostScalarFieldEnum>
    take?: number
    skip?: number
    count?: PostCountAggregateInputType
    avg?: PostAvgAggregateInputType
    sum?: PostSumAggregateInputType
    min?: PostMinAggregateInputType
    max?: PostMaxAggregateInputType
  }


  export type PostGroupByOutputType = {
    id: number | null
    createdAt: Date | null
    title: string | null
    content: string | null
    published: boolean | null
    authorId: number | null
    count: PostCountAggregateOutputType | null
    avg: PostAvgAggregateOutputType | null
    sum: PostSumAggregateOutputType | null
    min: PostMinAggregateOutputType | null
    max: PostMaxAggregateOutputType | null
  }

  type GetPostGroupByPayload<T extends GroupByPostArgs> = Promise<
    PickArray<PostGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof PostGroupByOutputType))]: GetScalarType<T[P], PostGroupByOutputType[P]>
    }
  >
    

  export type PostSelect = {
    id?: boolean
    createdAt?: boolean
    title?: boolean
    content?: boolean
    published?: boolean
    author?: boolean | UserArgs
    authorId?: boolean
  }

  export type PostInclude = {
    author?: boolean | UserArgs
  }

  export type PostGetPayload<
    S extends boolean | null | undefined | PostArgs,
    U = keyof S
      > = S extends true
        ? Post
    : S extends undefined
    ? never
    : S extends PostArgs | FindManyPostArgs
    ?'include' extends U
    ? Post  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'author'
        ? UserGetPayload<S['include'][P]> : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof Post ?Post [P]
  : 
          P extends 'author'
        ? UserGetPayload<S['select'][P]> : never
  } 
    : Post
  : Post


  export interface PostDelegate {
    /**
     * Find zero or one Post that matches the filter.
     * @param {FindUniquePostArgs} args - Arguments to find a Post
     * @example
     * // Get one Post
     * const post = await prisma.post.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniquePostArgs>(
      args: Subset<T, FindUniquePostArgs>
    ): CheckSelect<T, Prisma__PostClient<Post | null>, Prisma__PostClient<PostGetPayload<T> | null>>

    /**
     * Find the first Post that matches the filter.
     * @param {FindFirstPostArgs} args - Arguments to find a Post
     * @example
     * // Get one Post
     * const post = await prisma.post.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstPostArgs>(
      args?: Subset<T, FindFirstPostArgs>
    ): CheckSelect<T, Prisma__PostClient<Post | null>, Prisma__PostClient<PostGetPayload<T> | null>>

    /**
     * Find zero or more Posts that matches the filter.
     * @param {FindManyPostArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Posts
     * const posts = await prisma.post.findMany()
     * 
     * // Get first 10 Posts
     * const posts = await prisma.post.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const postWithIdOnly = await prisma.post.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyPostArgs>(
      args?: Subset<T, FindManyPostArgs>
    ): CheckSelect<T, Promise<Array<Post>>, Promise<Array<PostGetPayload<T>>>>

    /**
     * Create a Post.
     * @param {PostCreateArgs} args - Arguments to create a Post.
     * @example
     * // Create one Post
     * const Post = await prisma.post.create({
     *   data: {
     *     // ... data to create a Post
     *   }
     * })
     * 
    **/
    create<T extends PostCreateArgs>(
      args: Subset<T, PostCreateArgs>
    ): CheckSelect<T, Prisma__PostClient<Post>, Prisma__PostClient<PostGetPayload<T>>>

    /**
     * Delete a Post.
     * @param {PostDeleteArgs} args - Arguments to delete one Post.
     * @example
     * // Delete one Post
     * const Post = await prisma.post.delete({
     *   where: {
     *     // ... filter to delete one Post
     *   }
     * })
     * 
    **/
    delete<T extends PostDeleteArgs>(
      args: Subset<T, PostDeleteArgs>
    ): CheckSelect<T, Prisma__PostClient<Post>, Prisma__PostClient<PostGetPayload<T>>>

    /**
     * Update one Post.
     * @param {PostUpdateArgs} args - Arguments to update one Post.
     * @example
     * // Update one Post
     * const post = await prisma.post.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends PostUpdateArgs>(
      args: Subset<T, PostUpdateArgs>
    ): CheckSelect<T, Prisma__PostClient<Post>, Prisma__PostClient<PostGetPayload<T>>>

    /**
     * Delete zero or more Posts.
     * @param {PostDeleteManyArgs} args - Arguments to filter Posts to delete.
     * @example
     * // Delete a few Posts
     * const { count } = await prisma.post.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends PostDeleteManyArgs>(
      args?: Subset<T, PostDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Posts.
     * @param {PostUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Posts
     * const post = await prisma.post.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends PostUpdateManyArgs>(
      args: Subset<T, PostUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one Post.
     * @param {PostUpsertArgs} args - Arguments to update or create a Post.
     * @example
     * // Update or create a Post
     * const post = await prisma.post.upsert({
     *   create: {
     *     // ... data to create a Post
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Post we want to update
     *   }
     * })
    **/
    upsert<T extends PostUpsertArgs>(
      args: Subset<T, PostUpsertArgs>
    ): CheckSelect<T, Prisma__PostClient<Post>, Prisma__PostClient<PostGetPayload<T>>>

    /**
     * Find zero or one Post that matches the filter.
     * @param {FindUniquePostArgs} args - Arguments to find a Post
     * @deprecated This will be deprecated please use prisma.post.findUnique
     * @example
     * // Get one Post
     * const post = await prisma.post.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniquePostArgs>(
      args: Subset<T, FindUniquePostArgs>
    ): CheckSelect<T, Prisma__PostClient<Post | null>, Prisma__PostClient<PostGetPayload<T> | null>>

    /**
     * Count the number of Posts.
     * @param {FindManyPostArgs} args - Arguments to filter Posts to count.
     * @example
     * // Count the number of Posts
     * const count = await prisma.post.count({
     *   where: {
     *     // ... the filter for the Posts we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyPostArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a Post.
     * @param {AggregatePostArgs} 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 AggregatePostArgs>(args: Subset<T, AggregatePostArgs>): Promise<GetPostAggregateType<T>>

    /**
     * Group by Post.
     * @param {GroupByPostArgs} 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 GroupByPostArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByPostArgs['orderBy'] }
        : { orderBy?: GroupByPostArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByPostArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetPostGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for Post.
   * Why is this prefixed with \`Prisma__\`?
   * Because we want to prevent naming conflicts as mentioned in 
   * TEST_GITHUB_LINK
   */
  export class Prisma__PostClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    author<T extends UserArgs = {}>(args?: Subset<T, UserArgs>): CheckSelect<T, Prisma__UserClient<User | null>, Prisma__UserClient<UserGetPayload<T> | null>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * Post findUnique
   */
  export type FindUniquePostArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * Filter, which Post to fetch.
    **/
    where: PostWhereUniqueInput
  }


  /**
   * Post findFirst
   */
  export type FindFirstPostArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * Filter, which Post to fetch.
    **/
    where?: PostWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of Posts to fetch.
    **/
    orderBy?: Enumerable<PostOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Posts.
    **/
    cursor?: PostWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` Posts 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\` Posts.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of Posts.
    **/
    distinct?: Enumerable<PostScalarFieldEnum>
  }


  /**
   * Post findMany
   */
  export type FindManyPostArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * Filter, which Posts to fetch.
    **/
    where?: PostWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of Posts to fetch.
    **/
    orderBy?: Enumerable<PostOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Posts.
    **/
    cursor?: PostWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` Posts 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\` Posts.
    **/
    skip?: number
    distinct?: Enumerable<PostScalarFieldEnum>
  }


  /**
   * Post create
   */
  export type PostCreateArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * The data needed to create a Post.
    **/
    data: XOR<PostUncheckedCreateInput, PostCreateInput>
  }


  /**
   * Post update
   */
  export type PostUpdateArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * The data needed to update a Post.
    **/
    data: XOR<PostUncheckedUpdateInput, PostUpdateInput>
    /**
     * Choose, which Post to update.
    **/
    where: PostWhereUniqueInput
  }


  /**
   * Post updateMany
   */
  export type PostUpdateManyArgs = {
    data: XOR<PostUncheckedUpdateManyInput, PostUpdateManyMutationInput>
    where?: PostWhereInput
  }


  /**
   * Post upsert
   */
  export type PostUpsertArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * The filter to search for the Post to update in case it exists.
    **/
    where: PostWhereUniqueInput
    /**
     * In case the Post found by the \`where\` argument doesn't exist, create a new Post with this data.
    **/
    create: XOR<PostUncheckedCreateInput, PostCreateInput>
    /**
     * In case the Post was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<PostUncheckedUpdateInput, PostUpdateInput>
  }


  /**
   * Post delete
   */
  export type PostDeleteArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
    /**
     * Filter which Post to delete.
    **/
    where: PostWhereUniqueInput
  }


  /**
   * Post deleteMany
   */
  export type PostDeleteManyArgs = {
    where?: PostWhereInput
  }


  /**
   * Post without action
   */
  export type PostArgs = {
    /**
     * Select specific fields to fetch from the Post
    **/
    select?: PostSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: PostInclude | null
  }



  /**
   * Model User
   */


  export type AggregateUser = {
    count: number | null
    avg: UserAvgAggregateOutputType | null
    sum: UserSumAggregateOutputType | null
    min: UserMinAggregateOutputType | null
    max: UserMaxAggregateOutputType | null
  }

  export type UserAvgAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type UserSumAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type UserMinAggregateOutputType = {
    id: number
    email: string | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type UserMaxAggregateOutputType = {
    id: number
    email: string | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    email: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type UserAvgAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type UserSumAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type UserMinAggregateInputType = {
    id?: true
    email?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    email?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    email?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateUserArgs = {
    /**
     * Filter which User to aggregate.
    **/
    where?: UserWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of Users to fetch.
    **/
    orderBy?: Enumerable<UserOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` Users 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\` Users.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Users
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: UserAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: UserSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: UserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: UserMaxAggregateInputType
  }

  export type GetUserAggregateType<T extends AggregateUserArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetUserAggregateScalarType<T[P]>
  }

  export type GetUserAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof UserAvgAggregateOutputType ? UserAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByUserArgs = {
    where?: UserWhereInput
    orderBy?: Enumerable<UserOrderByInput>
    by: Array<UserScalarFieldEnum>
    take?: number
    skip?: number
    count?: UserCountAggregateInputType
    avg?: UserAvgAggregateInputType
    sum?: UserSumAggregateInputType
    min?: UserMinAggregateInputType
    max?: UserMaxAggregateInputType
  }


  export type UserGroupByOutputType = {
    id: number | null
    email: string | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: UserCountAggregateOutputType | null
    avg: UserAvgAggregateOutputType | null
    sum: UserSumAggregateOutputType | null
    min: UserMinAggregateOutputType | null
    max: UserMaxAggregateOutputType | null
  }

  type GetUserGroupByPayload<T extends GroupByUserArgs> = Promise<
    PickArray<UserGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof UserGroupByOutputType))]: GetScalarType<T[P], UserGroupByOutputType[P]>
    }
  >
    

  export type UserSelect = {
    id?: boolean
    email?: boolean
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
    posts?: boolean | FindManyPostArgs
  }

  export type UserInclude = {
    posts?: boolean | FindManyPostArgs
  }

  export type UserGetPayload<
    S extends boolean | null | undefined | UserArgs,
    U = keyof S
      > = S extends true
        ? User
    : S extends undefined
    ? never
    : S extends UserArgs | FindManyUserArgs
    ?'include' extends U
    ? User  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'posts'
        ? Array < PostGetPayload<S['include'][P]>>  : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof User ?User [P]
  : 
          P extends 'posts'
        ? Array < PostGetPayload<S['select'][P]>>  : never
  } 
    : User
  : User


  export interface UserDelegate {
    /**
     * Find zero or one User that matches the filter.
     * @param {FindUniqueUserArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueUserArgs>(
      args: Subset<T, FindUniqueUserArgs>
    ): CheckSelect<T, Prisma__UserClient<User | null>, Prisma__UserClient<UserGetPayload<T> | null>>

    /**
     * Find the first User that matches the filter.
     * @param {FindFirstUserArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstUserArgs>(
      args?: Subset<T, FindFirstUserArgs>
    ): CheckSelect<T, Prisma__UserClient<User | null>, Prisma__UserClient<UserGetPayload<T> | null>>

    /**
     * Find zero or more Users that matches the filter.
     * @param {FindManyUserArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Users
     * const users = await prisma.user.findMany()
     * 
     * // Get first 10 Users
     * const users = await prisma.user.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const userWithIdOnly = await prisma.user.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyUserArgs>(
      args?: Subset<T, FindManyUserArgs>
    ): CheckSelect<T, Promise<Array<User>>, Promise<Array<UserGetPayload<T>>>>

    /**
     * Create a User.
     * @param {UserCreateArgs} args - Arguments to create a User.
     * @example
     * // Create one User
     * const User = await prisma.user.create({
     *   data: {
     *     // ... data to create a User
     *   }
     * })
     * 
    **/
    create<T extends UserCreateArgs>(
      args: Subset<T, UserCreateArgs>
    ): CheckSelect<T, Prisma__UserClient<User>, Prisma__UserClient<UserGetPayload<T>>>

    /**
     * Delete a User.
     * @param {UserDeleteArgs} args - Arguments to delete one User.
     * @example
     * // Delete one User
     * const User = await prisma.user.delete({
     *   where: {
     *     // ... filter to delete one User
     *   }
     * })
     * 
    **/
    delete<T extends UserDeleteArgs>(
      args: Subset<T, UserDeleteArgs>
    ): CheckSelect<T, Prisma__UserClient<User>, Prisma__UserClient<UserGetPayload<T>>>

    /**
     * Update one User.
     * @param {UserUpdateArgs} args - Arguments to update one User.
     * @example
     * // Update one User
     * const user = await prisma.user.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends UserUpdateArgs>(
      args: Subset<T, UserUpdateArgs>
    ): CheckSelect<T, Prisma__UserClient<User>, Prisma__UserClient<UserGetPayload<T>>>

    /**
     * Delete zero or more Users.
     * @param {UserDeleteManyArgs} args - Arguments to filter Users to delete.
     * @example
     * // Delete a few Users
     * const { count } = await prisma.user.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends UserDeleteManyArgs>(
      args?: Subset<T, UserDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Users.
     * @param {UserUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Users
     * const user = await prisma.user.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends UserUpdateManyArgs>(
      args: Subset<T, UserUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one User.
     * @param {UserUpsertArgs} args - Arguments to update or create a User.
     * @example
     * // Update or create a User
     * const user = await prisma.user.upsert({
     *   create: {
     *     // ... data to create a User
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the User we want to update
     *   }
     * })
    **/
    upsert<T extends UserUpsertArgs>(
      args: Subset<T, UserUpsertArgs>
    ): CheckSelect<T, Prisma__UserClient<User>, Prisma__UserClient<UserGetPayload<T>>>

    /**
     * Find zero or one User that matches the filter.
     * @param {FindUniqueUserArgs} args - Arguments to find a User
     * @deprecated This will be deprecated please use prisma.user.findUnique
     * @example
     * // Get one User
     * const user = await prisma.user.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueUserArgs>(
      args: Subset<T, FindUniqueUserArgs>
    ): CheckSelect<T, Prisma__UserClient<User | null>, Prisma__UserClient<UserGetPayload<T> | null>>

    /**
     * Count the number of Users.
     * @param {FindManyUserArgs} args - Arguments to filter Users to count.
     * @example
     * // Count the number of Users
     * const count = await prisma.user.count({
     *   where: {
     *     // ... the filter for the Users we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyUserArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a User.
     * @param {AggregateUserArgs} 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 AggregateUserArgs>(args: Subset<T, AggregateUserArgs>): Promise<GetUserAggregateType<T>>

    /**
     * Group by User.
     * @param {GroupByUserArgs} 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 GroupByUserArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByUserArgs['orderBy'] }
        : { orderBy?: GroupByUserArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByUserArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetUserGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for User.
   * 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 class Prisma__UserClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    posts<T extends FindManyPostArgs = {}>(args?: Subset<T, FindManyPostArgs>): CheckSelect<T, Promise<Array<Post>>, Promise<Array<PostGetPayload<T>>>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * User findUnique
   */
  export type FindUniqueUserArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * Filter, which User to fetch.
    **/
    where: UserWhereUniqueInput
  }


  /**
   * User findFirst
   */
  export type FindFirstUserArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * Filter, which User to fetch.
    **/
    where?: UserWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of Users to fetch.
    **/
    orderBy?: Enumerable<UserOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
    **/
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` Users 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\` Users.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of Users.
    **/
    distinct?: Enumerable<UserScalarFieldEnum>
  }


  /**
   * User findMany
   */
  export type FindManyUserArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * Filter, which Users to fetch.
    **/
    where?: UserWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of Users to fetch.
    **/
    orderBy?: Enumerable<UserOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Users.
    **/
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` Users 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\` Users.
    **/
    skip?: number
    distinct?: Enumerable<UserScalarFieldEnum>
  }


  /**
   * User create
   */
  export type UserCreateArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * The data needed to create a User.
    **/
    data: XOR<UserUncheckedCreateInput, UserCreateInput>
  }


  /**
   * User update
   */
  export type UserUpdateArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * The data needed to update a User.
    **/
    data: XOR<UserUncheckedUpdateInput, UserUpdateInput>
    /**
     * Choose, which User to update.
    **/
    where: UserWhereUniqueInput
  }


  /**
   * User updateMany
   */
  export type UserUpdateManyArgs = {
    data: XOR<UserUncheckedUpdateManyInput, UserUpdateManyMutationInput>
    where?: UserWhereInput
  }


  /**
   * User upsert
   */
  export type UserUpsertArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * The filter to search for the User to update in case it exists.
    **/
    where: UserWhereUniqueInput
    /**
     * In case the User found by the \`where\` argument doesn't exist, create a new User with this data.
    **/
    create: XOR<UserUncheckedCreateInput, UserCreateInput>
    /**
     * In case the User was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<UserUncheckedUpdateInput, UserUpdateInput>
  }


  /**
   * User delete
   */
  export type UserDeleteArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
    /**
     * Filter which User to delete.
    **/
    where: UserWhereUniqueInput
  }


  /**
   * User deleteMany
   */
  export type UserDeleteManyArgs = {
    where?: UserWhereInput
  }


  /**
   * User without action
   */
  export type UserArgs = {
    /**
     * Select specific fields to fetch from the User
    **/
    select?: UserSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: UserInclude | null
  }



  /**
   * Model M
   */


  export type AggregateM = {
    count: number | null
    avg: MAvgAggregateOutputType | null
    sum: MSumAggregateOutputType | null
    min: MMinAggregateOutputType | null
    max: MMaxAggregateOutputType | null
  }

  export type MAvgAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type MSumAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type MMinAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type MMaxAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type MCountAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type MAvgAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type MSumAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type MMinAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type MMaxAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type MCountAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateMArgs = {
    /**
     * Filter which M to aggregate.
    **/
    where?: MWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of MS to fetch.
    **/
    orderBy?: Enumerable<MOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: MWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` MS 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\` MS.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MS
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: MAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: MSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: MMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: MMaxAggregateInputType
  }

  export type GetMAggregateType<T extends AggregateMArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetMAggregateScalarType<T[P]>
  }

  export type GetMAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof MAvgAggregateOutputType ? MAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByMArgs = {
    where?: MWhereInput
    orderBy?: Enumerable<MOrderByInput>
    by: Array<MScalarFieldEnum>
    take?: number
    skip?: number
    count?: MCountAggregateInputType
    avg?: MAvgAggregateInputType
    sum?: MSumAggregateInputType
    min?: MMinAggregateInputType
    max?: MMaxAggregateInputType
  }


  export type MGroupByOutputType = {
    id: number | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: MCountAggregateOutputType | null
    avg: MAvgAggregateOutputType | null
    sum: MSumAggregateOutputType | null
    min: MMinAggregateOutputType | null
    max: MMaxAggregateOutputType | null
  }

  type GetMGroupByPayload<T extends GroupByMArgs> = Promise<
    PickArray<MGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof MGroupByOutputType))]: GetScalarType<T[P], MGroupByOutputType[P]>
    }
  >
    

  export type MSelect = {
    id?: boolean
    n?: boolean | FindManyNArgs
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
  }

  export type MInclude = {
    n?: boolean | FindManyNArgs
  }

  export type MGetPayload<
    S extends boolean | null | undefined | MArgs,
    U = keyof S
      > = S extends true
        ? M
    : S extends undefined
    ? never
    : S extends MArgs | FindManyMArgs
    ?'include' extends U
    ? M  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'n'
        ? Array < NGetPayload<S['include'][P]>>  : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof M ?M [P]
  : 
          P extends 'n'
        ? Array < NGetPayload<S['select'][P]>>  : never
  } 
    : M
  : M


  export interface MDelegate {
    /**
     * Find zero or one M that matches the filter.
     * @param {FindUniqueMArgs} args - Arguments to find a M
     * @example
     * // Get one M
     * const m = await prisma.m.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueMArgs>(
      args: Subset<T, FindUniqueMArgs>
    ): CheckSelect<T, Prisma__MClient<M | null>, Prisma__MClient<MGetPayload<T> | null>>

    /**
     * Find the first M that matches the filter.
     * @param {FindFirstMArgs} args - Arguments to find a M
     * @example
     * // Get one M
     * const m = await prisma.m.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstMArgs>(
      args?: Subset<T, FindFirstMArgs>
    ): CheckSelect<T, Prisma__MClient<M | null>, Prisma__MClient<MGetPayload<T> | null>>

    /**
     * Find zero or more Ms that matches the filter.
     * @param {FindManyMArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Ms
     * const ms = await prisma.m.findMany()
     * 
     * // Get first 10 Ms
     * const ms = await prisma.m.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const mWithIdOnly = await prisma.m.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyMArgs>(
      args?: Subset<T, FindManyMArgs>
    ): CheckSelect<T, Promise<Array<M>>, Promise<Array<MGetPayload<T>>>>

    /**
     * Create a M.
     * @param {MCreateArgs} args - Arguments to create a M.
     * @example
     * // Create one M
     * const M = await prisma.m.create({
     *   data: {
     *     // ... data to create a M
     *   }
     * })
     * 
    **/
    create<T extends MCreateArgs>(
      args: Subset<T, MCreateArgs>
    ): CheckSelect<T, Prisma__MClient<M>, Prisma__MClient<MGetPayload<T>>>

    /**
     * Delete a M.
     * @param {MDeleteArgs} args - Arguments to delete one M.
     * @example
     * // Delete one M
     * const M = await prisma.m.delete({
     *   where: {
     *     // ... filter to delete one M
     *   }
     * })
     * 
    **/
    delete<T extends MDeleteArgs>(
      args: Subset<T, MDeleteArgs>
    ): CheckSelect<T, Prisma__MClient<M>, Prisma__MClient<MGetPayload<T>>>

    /**
     * Update one M.
     * @param {MUpdateArgs} args - Arguments to update one M.
     * @example
     * // Update one M
     * const m = await prisma.m.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends MUpdateArgs>(
      args: Subset<T, MUpdateArgs>
    ): CheckSelect<T, Prisma__MClient<M>, Prisma__MClient<MGetPayload<T>>>

    /**
     * Delete zero or more Ms.
     * @param {MDeleteManyArgs} args - Arguments to filter Ms to delete.
     * @example
     * // Delete a few Ms
     * const { count } = await prisma.m.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends MDeleteManyArgs>(
      args?: Subset<T, MDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Ms.
     * @param {MUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Ms
     * const m = await prisma.m.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends MUpdateManyArgs>(
      args: Subset<T, MUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one M.
     * @param {MUpsertArgs} args - Arguments to update or create a M.
     * @example
     * // Update or create a M
     * const m = await prisma.m.upsert({
     *   create: {
     *     // ... data to create a M
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the M we want to update
     *   }
     * })
    **/
    upsert<T extends MUpsertArgs>(
      args: Subset<T, MUpsertArgs>
    ): CheckSelect<T, Prisma__MClient<M>, Prisma__MClient<MGetPayload<T>>>

    /**
     * Find zero or one M that matches the filter.
     * @param {FindUniqueMArgs} args - Arguments to find a M
     * @deprecated This will be deprecated please use prisma.m.findUnique
     * @example
     * // Get one M
     * const m = await prisma.m.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueMArgs>(
      args: Subset<T, FindUniqueMArgs>
    ): CheckSelect<T, Prisma__MClient<M | null>, Prisma__MClient<MGetPayload<T> | null>>

    /**
     * Count the number of Ms.
     * @param {FindManyMArgs} args - Arguments to filter Ms to count.
     * @example
     * // Count the number of Ms
     * const count = await prisma.m.count({
     *   where: {
     *     // ... the filter for the Ms we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyMArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a M.
     * @param {AggregateMArgs} 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 AggregateMArgs>(args: Subset<T, AggregateMArgs>): Promise<GetMAggregateType<T>>

    /**
     * Group by M.
     * @param {GroupByMArgs} 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 GroupByMArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByMArgs['orderBy'] }
        : { orderBy?: GroupByMArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByMArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetMGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for M.
   * 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 class Prisma__MClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    n<T extends FindManyNArgs = {}>(args?: Subset<T, FindManyNArgs>): CheckSelect<T, Promise<Array<N>>, Promise<Array<NGetPayload<T>>>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * M findUnique
   */
  export type FindUniqueMArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * Filter, which M to fetch.
    **/
    where: MWhereUniqueInput
  }


  /**
   * M findFirst
   */
  export type FindFirstMArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * Filter, which M to fetch.
    **/
    where?: MWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of MS to fetch.
    **/
    orderBy?: Enumerable<MOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MS.
    **/
    cursor?: MWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` MS 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\` MS.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of MS.
    **/
    distinct?: Enumerable<MScalarFieldEnum>
  }


  /**
   * M findMany
   */
  export type FindManyMArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * Filter, which MS to fetch.
    **/
    where?: MWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of MS to fetch.
    **/
    orderBy?: Enumerable<MOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MS.
    **/
    cursor?: MWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` MS 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\` MS.
    **/
    skip?: number
    distinct?: Enumerable<MScalarFieldEnum>
  }


  /**
   * M create
   */
  export type MCreateArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * The data needed to create a M.
    **/
    data: XOR<MUncheckedCreateInput, MCreateInput>
  }


  /**
   * M update
   */
  export type MUpdateArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * The data needed to update a M.
    **/
    data: XOR<MUncheckedUpdateInput, MUpdateInput>
    /**
     * Choose, which M to update.
    **/
    where: MWhereUniqueInput
  }


  /**
   * M updateMany
   */
  export type MUpdateManyArgs = {
    data: XOR<MUncheckedUpdateManyInput, MUpdateManyMutationInput>
    where?: MWhereInput
  }


  /**
   * M upsert
   */
  export type MUpsertArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * The filter to search for the M to update in case it exists.
    **/
    where: MWhereUniqueInput
    /**
     * In case the M found by the \`where\` argument doesn't exist, create a new M with this data.
    **/
    create: XOR<MUncheckedCreateInput, MCreateInput>
    /**
     * In case the M was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<MUncheckedUpdateInput, MUpdateInput>
  }


  /**
   * M delete
   */
  export type MDeleteArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
    /**
     * Filter which M to delete.
    **/
    where: MWhereUniqueInput
  }


  /**
   * M deleteMany
   */
  export type MDeleteManyArgs = {
    where?: MWhereInput
  }


  /**
   * M without action
   */
  export type MArgs = {
    /**
     * Select specific fields to fetch from the M
    **/
    select?: MSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: MInclude | null
  }



  /**
   * Model N
   */


  export type AggregateN = {
    count: number | null
    avg: NAvgAggregateOutputType | null
    sum: NSumAggregateOutputType | null
    min: NMinAggregateOutputType | null
    max: NMaxAggregateOutputType | null
  }

  export type NAvgAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type NSumAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type NMinAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type NMaxAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type NCountAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type NAvgAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type NSumAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type NMinAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type NMaxAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type NCountAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateNArgs = {
    /**
     * Filter which N to aggregate.
    **/
    where?: NWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of NS to fetch.
    **/
    orderBy?: Enumerable<NOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: NWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` NS 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\` NS.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned NS
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: NAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: NSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: NMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: NMaxAggregateInputType
  }

  export type GetNAggregateType<T extends AggregateNArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetNAggregateScalarType<T[P]>
  }

  export type GetNAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof NAvgAggregateOutputType ? NAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByNArgs = {
    where?: NWhereInput
    orderBy?: Enumerable<NOrderByInput>
    by: Array<NScalarFieldEnum>
    take?: number
    skip?: number
    count?: NCountAggregateInputType
    avg?: NAvgAggregateInputType
    sum?: NSumAggregateInputType
    min?: NMinAggregateInputType
    max?: NMaxAggregateInputType
  }


  export type NGroupByOutputType = {
    id: number | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: NCountAggregateOutputType | null
    avg: NAvgAggregateOutputType | null
    sum: NSumAggregateOutputType | null
    min: NMinAggregateOutputType | null
    max: NMaxAggregateOutputType | null
  }

  type GetNGroupByPayload<T extends GroupByNArgs> = Promise<
    PickArray<NGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof NGroupByOutputType))]: GetScalarType<T[P], NGroupByOutputType[P]>
    }
  >
    

  export type NSelect = {
    id?: boolean
    m?: boolean | FindManyMArgs
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
  }

  export type NInclude = {
    m?: boolean | FindManyMArgs
  }

  export type NGetPayload<
    S extends boolean | null | undefined | NArgs,
    U = keyof S
      > = S extends true
        ? N
    : S extends undefined
    ? never
    : S extends NArgs | FindManyNArgs
    ?'include' extends U
    ? N  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'm'
        ? Array < MGetPayload<S['include'][P]>>  : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof N ?N [P]
  : 
          P extends 'm'
        ? Array < MGetPayload<S['select'][P]>>  : never
  } 
    : N
  : N


  export interface NDelegate {
    /**
     * Find zero or one N that matches the filter.
     * @param {FindUniqueNArgs} args - Arguments to find a N
     * @example
     * // Get one N
     * const n = await prisma.n.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueNArgs>(
      args: Subset<T, FindUniqueNArgs>
    ): CheckSelect<T, Prisma__NClient<N | null>, Prisma__NClient<NGetPayload<T> | null>>

    /**
     * Find the first N that matches the filter.
     * @param {FindFirstNArgs} args - Arguments to find a N
     * @example
     * // Get one N
     * const n = await prisma.n.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstNArgs>(
      args?: Subset<T, FindFirstNArgs>
    ): CheckSelect<T, Prisma__NClient<N | null>, Prisma__NClient<NGetPayload<T> | null>>

    /**
     * Find zero or more Ns that matches the filter.
     * @param {FindManyNArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Ns
     * const ns = await prisma.n.findMany()
     * 
     * // Get first 10 Ns
     * const ns = await prisma.n.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const nWithIdOnly = await prisma.n.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyNArgs>(
      args?: Subset<T, FindManyNArgs>
    ): CheckSelect<T, Promise<Array<N>>, Promise<Array<NGetPayload<T>>>>

    /**
     * Create a N.
     * @param {NCreateArgs} args - Arguments to create a N.
     * @example
     * // Create one N
     * const N = await prisma.n.create({
     *   data: {
     *     // ... data to create a N
     *   }
     * })
     * 
    **/
    create<T extends NCreateArgs>(
      args: Subset<T, NCreateArgs>
    ): CheckSelect<T, Prisma__NClient<N>, Prisma__NClient<NGetPayload<T>>>

    /**
     * Delete a N.
     * @param {NDeleteArgs} args - Arguments to delete one N.
     * @example
     * // Delete one N
     * const N = await prisma.n.delete({
     *   where: {
     *     // ... filter to delete one N
     *   }
     * })
     * 
    **/
    delete<T extends NDeleteArgs>(
      args: Subset<T, NDeleteArgs>
    ): CheckSelect<T, Prisma__NClient<N>, Prisma__NClient<NGetPayload<T>>>

    /**
     * Update one N.
     * @param {NUpdateArgs} args - Arguments to update one N.
     * @example
     * // Update one N
     * const n = await prisma.n.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends NUpdateArgs>(
      args: Subset<T, NUpdateArgs>
    ): CheckSelect<T, Prisma__NClient<N>, Prisma__NClient<NGetPayload<T>>>

    /**
     * Delete zero or more Ns.
     * @param {NDeleteManyArgs} args - Arguments to filter Ns to delete.
     * @example
     * // Delete a few Ns
     * const { count } = await prisma.n.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends NDeleteManyArgs>(
      args?: Subset<T, NDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Ns.
     * @param {NUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Ns
     * const n = await prisma.n.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends NUpdateManyArgs>(
      args: Subset<T, NUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one N.
     * @param {NUpsertArgs} args - Arguments to update or create a N.
     * @example
     * // Update or create a N
     * const n = await prisma.n.upsert({
     *   create: {
     *     // ... data to create a N
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the N we want to update
     *   }
     * })
    **/
    upsert<T extends NUpsertArgs>(
      args: Subset<T, NUpsertArgs>
    ): CheckSelect<T, Prisma__NClient<N>, Prisma__NClient<NGetPayload<T>>>

    /**
     * Find zero or one N that matches the filter.
     * @param {FindUniqueNArgs} args - Arguments to find a N
     * @deprecated This will be deprecated please use prisma.n.findUnique
     * @example
     * // Get one N
     * const n = await prisma.n.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueNArgs>(
      args: Subset<T, FindUniqueNArgs>
    ): CheckSelect<T, Prisma__NClient<N | null>, Prisma__NClient<NGetPayload<T> | null>>

    /**
     * Count the number of Ns.
     * @param {FindManyNArgs} args - Arguments to filter Ns to count.
     * @example
     * // Count the number of Ns
     * const count = await prisma.n.count({
     *   where: {
     *     // ... the filter for the Ns we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyNArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a N.
     * @param {AggregateNArgs} 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 AggregateNArgs>(args: Subset<T, AggregateNArgs>): Promise<GetNAggregateType<T>>

    /**
     * Group by N.
     * @param {GroupByNArgs} 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 GroupByNArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByNArgs['orderBy'] }
        : { orderBy?: GroupByNArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByNArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetNGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for N.
   * 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 class Prisma__NClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    m<T extends FindManyMArgs = {}>(args?: Subset<T, FindManyMArgs>): CheckSelect<T, Promise<Array<M>>, Promise<Array<MGetPayload<T>>>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * N findUnique
   */
  export type FindUniqueNArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * Filter, which N to fetch.
    **/
    where: NWhereUniqueInput
  }


  /**
   * N findFirst
   */
  export type FindFirstNArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * Filter, which N to fetch.
    **/
    where?: NWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of NS to fetch.
    **/
    orderBy?: Enumerable<NOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for NS.
    **/
    cursor?: NWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` NS 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\` NS.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of NS.
    **/
    distinct?: Enumerable<NScalarFieldEnum>
  }


  /**
   * N findMany
   */
  export type FindManyNArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * Filter, which NS to fetch.
    **/
    where?: NWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of NS to fetch.
    **/
    orderBy?: Enumerable<NOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing NS.
    **/
    cursor?: NWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` NS 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\` NS.
    **/
    skip?: number
    distinct?: Enumerable<NScalarFieldEnum>
  }


  /**
   * N create
   */
  export type NCreateArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * The data needed to create a N.
    **/
    data: XOR<NUncheckedCreateInput, NCreateInput>
  }


  /**
   * N update
   */
  export type NUpdateArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * The data needed to update a N.
    **/
    data: XOR<NUncheckedUpdateInput, NUpdateInput>
    /**
     * Choose, which N to update.
    **/
    where: NWhereUniqueInput
  }


  /**
   * N updateMany
   */
  export type NUpdateManyArgs = {
    data: XOR<NUncheckedUpdateManyInput, NUpdateManyMutationInput>
    where?: NWhereInput
  }


  /**
   * N upsert
   */
  export type NUpsertArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * The filter to search for the N to update in case it exists.
    **/
    where: NWhereUniqueInput
    /**
     * In case the N found by the \`where\` argument doesn't exist, create a new N with this data.
    **/
    create: XOR<NUncheckedCreateInput, NCreateInput>
    /**
     * In case the N was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<NUncheckedUpdateInput, NUpdateInput>
  }


  /**
   * N delete
   */
  export type NDeleteArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
    /**
     * Filter which N to delete.
    **/
    where: NWhereUniqueInput
  }


  /**
   * N deleteMany
   */
  export type NDeleteManyArgs = {
    where?: NWhereInput
  }


  /**
   * N without action
   */
  export type NArgs = {
    /**
     * Select specific fields to fetch from the N
    **/
    select?: NSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: NInclude | null
  }



  /**
   * Model OneOptional
   */


  export type AggregateOneOptional = {
    count: number | null
    avg: OneOptionalAvgAggregateOutputType | null
    sum: OneOptionalSumAggregateOutputType | null
    min: OneOptionalMinAggregateOutputType | null
    max: OneOptionalMaxAggregateOutputType | null
  }

  export type OneOptionalAvgAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type OneOptionalSumAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type OneOptionalMinAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type OneOptionalMaxAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type OneOptionalCountAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type OneOptionalAvgAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type OneOptionalSumAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type OneOptionalMinAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type OneOptionalMaxAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type OneOptionalCountAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateOneOptionalArgs = {
    /**
     * Filter which OneOptional to aggregate.
    **/
    where?: OneOptionalWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OneOptionals to fetch.
    **/
    orderBy?: Enumerable<OneOptionalOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: OneOptionalWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OneOptionals 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\` OneOptionals.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned OneOptionals
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: OneOptionalAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: OneOptionalSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: OneOptionalMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: OneOptionalMaxAggregateInputType
  }

  export type GetOneOptionalAggregateType<T extends AggregateOneOptionalArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetOneOptionalAggregateScalarType<T[P]>
  }

  export type GetOneOptionalAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof OneOptionalAvgAggregateOutputType ? OneOptionalAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByOneOptionalArgs = {
    where?: OneOptionalWhereInput
    orderBy?: Enumerable<OneOptionalOrderByInput>
    by: Array<OneOptionalScalarFieldEnum>
    take?: number
    skip?: number
    count?: OneOptionalCountAggregateInputType
    avg?: OneOptionalAvgAggregateInputType
    sum?: OneOptionalSumAggregateInputType
    min?: OneOptionalMinAggregateInputType
    max?: OneOptionalMaxAggregateInputType
  }


  export type OneOptionalGroupByOutputType = {
    id: number | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: OneOptionalCountAggregateOutputType | null
    avg: OneOptionalAvgAggregateOutputType | null
    sum: OneOptionalSumAggregateOutputType | null
    min: OneOptionalMinAggregateOutputType | null
    max: OneOptionalMaxAggregateOutputType | null
  }

  type GetOneOptionalGroupByPayload<T extends GroupByOneOptionalArgs> = Promise<
    PickArray<OneOptionalGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof OneOptionalGroupByOutputType))]: GetScalarType<T[P], OneOptionalGroupByOutputType[P]>
    }
  >
    

  export type OneOptionalSelect = {
    id?: boolean
    many?: boolean | FindManyManyRequiredArgs
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
  }

  export type OneOptionalInclude = {
    many?: boolean | FindManyManyRequiredArgs
  }

  export type OneOptionalGetPayload<
    S extends boolean | null | undefined | OneOptionalArgs,
    U = keyof S
      > = S extends true
        ? OneOptional
    : S extends undefined
    ? never
    : S extends OneOptionalArgs | FindManyOneOptionalArgs
    ?'include' extends U
    ? OneOptional  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'many'
        ? Array < ManyRequiredGetPayload<S['include'][P]>>  : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof OneOptional ?OneOptional [P]
  : 
          P extends 'many'
        ? Array < ManyRequiredGetPayload<S['select'][P]>>  : never
  } 
    : OneOptional
  : OneOptional


  export interface OneOptionalDelegate {
    /**
     * Find zero or one OneOptional that matches the filter.
     * @param {FindUniqueOneOptionalArgs} args - Arguments to find a OneOptional
     * @example
     * // Get one OneOptional
     * const oneOptional = await prisma.oneOptional.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueOneOptionalArgs>(
      args: Subset<T, FindUniqueOneOptionalArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional | null>, Prisma__OneOptionalClient<OneOptionalGetPayload<T> | null>>

    /**
     * Find the first OneOptional that matches the filter.
     * @param {FindFirstOneOptionalArgs} args - Arguments to find a OneOptional
     * @example
     * // Get one OneOptional
     * const oneOptional = await prisma.oneOptional.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstOneOptionalArgs>(
      args?: Subset<T, FindFirstOneOptionalArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional | null>, Prisma__OneOptionalClient<OneOptionalGetPayload<T> | null>>

    /**
     * Find zero or more OneOptionals that matches the filter.
     * @param {FindManyOneOptionalArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all OneOptionals
     * const oneOptionals = await prisma.oneOptional.findMany()
     * 
     * // Get first 10 OneOptionals
     * const oneOptionals = await prisma.oneOptional.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const oneOptionalWithIdOnly = await prisma.oneOptional.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyOneOptionalArgs>(
      args?: Subset<T, FindManyOneOptionalArgs>
    ): CheckSelect<T, Promise<Array<OneOptional>>, Promise<Array<OneOptionalGetPayload<T>>>>

    /**
     * Create a OneOptional.
     * @param {OneOptionalCreateArgs} args - Arguments to create a OneOptional.
     * @example
     * // Create one OneOptional
     * const OneOptional = await prisma.oneOptional.create({
     *   data: {
     *     // ... data to create a OneOptional
     *   }
     * })
     * 
    **/
    create<T extends OneOptionalCreateArgs>(
      args: Subset<T, OneOptionalCreateArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional>, Prisma__OneOptionalClient<OneOptionalGetPayload<T>>>

    /**
     * Delete a OneOptional.
     * @param {OneOptionalDeleteArgs} args - Arguments to delete one OneOptional.
     * @example
     * // Delete one OneOptional
     * const OneOptional = await prisma.oneOptional.delete({
     *   where: {
     *     // ... filter to delete one OneOptional
     *   }
     * })
     * 
    **/
    delete<T extends OneOptionalDeleteArgs>(
      args: Subset<T, OneOptionalDeleteArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional>, Prisma__OneOptionalClient<OneOptionalGetPayload<T>>>

    /**
     * Update one OneOptional.
     * @param {OneOptionalUpdateArgs} args - Arguments to update one OneOptional.
     * @example
     * // Update one OneOptional
     * const oneOptional = await prisma.oneOptional.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends OneOptionalUpdateArgs>(
      args: Subset<T, OneOptionalUpdateArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional>, Prisma__OneOptionalClient<OneOptionalGetPayload<T>>>

    /**
     * Delete zero or more OneOptionals.
     * @param {OneOptionalDeleteManyArgs} args - Arguments to filter OneOptionals to delete.
     * @example
     * // Delete a few OneOptionals
     * const { count } = await prisma.oneOptional.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends OneOptionalDeleteManyArgs>(
      args?: Subset<T, OneOptionalDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more OneOptionals.
     * @param {OneOptionalUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many OneOptionals
     * const oneOptional = await prisma.oneOptional.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends OneOptionalUpdateManyArgs>(
      args: Subset<T, OneOptionalUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one OneOptional.
     * @param {OneOptionalUpsertArgs} args - Arguments to update or create a OneOptional.
     * @example
     * // Update or create a OneOptional
     * const oneOptional = await prisma.oneOptional.upsert({
     *   create: {
     *     // ... data to create a OneOptional
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the OneOptional we want to update
     *   }
     * })
    **/
    upsert<T extends OneOptionalUpsertArgs>(
      args: Subset<T, OneOptionalUpsertArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional>, Prisma__OneOptionalClient<OneOptionalGetPayload<T>>>

    /**
     * Find zero or one OneOptional that matches the filter.
     * @param {FindUniqueOneOptionalArgs} args - Arguments to find a OneOptional
     * @deprecated This will be deprecated please use prisma.oneOptional.findUnique
     * @example
     * // Get one OneOptional
     * const oneOptional = await prisma.oneOptional.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueOneOptionalArgs>(
      args: Subset<T, FindUniqueOneOptionalArgs>
    ): CheckSelect<T, Prisma__OneOptionalClient<OneOptional | null>, Prisma__OneOptionalClient<OneOptionalGetPayload<T> | null>>

    /**
     * Count the number of OneOptionals.
     * @param {FindManyOneOptionalArgs} args - Arguments to filter OneOptionals to count.
     * @example
     * // Count the number of OneOptionals
     * const count = await prisma.oneOptional.count({
     *   where: {
     *     // ... the filter for the OneOptionals we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyOneOptionalArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a OneOptional.
     * @param {AggregateOneOptionalArgs} 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 AggregateOneOptionalArgs>(args: Subset<T, AggregateOneOptionalArgs>): Promise<GetOneOptionalAggregateType<T>>

    /**
     * Group by OneOptional.
     * @param {GroupByOneOptionalArgs} 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 GroupByOneOptionalArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByOneOptionalArgs['orderBy'] }
        : { orderBy?: GroupByOneOptionalArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByOneOptionalArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetOneOptionalGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for OneOptional.
   * 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 class Prisma__OneOptionalClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    many<T extends FindManyManyRequiredArgs = {}>(args?: Subset<T, FindManyManyRequiredArgs>): CheckSelect<T, Promise<Array<ManyRequired>>, Promise<Array<ManyRequiredGetPayload<T>>>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * OneOptional findUnique
   */
  export type FindUniqueOneOptionalArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * Filter, which OneOptional to fetch.
    **/
    where: OneOptionalWhereUniqueInput
  }


  /**
   * OneOptional findFirst
   */
  export type FindFirstOneOptionalArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * Filter, which OneOptional to fetch.
    **/
    where?: OneOptionalWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OneOptionals to fetch.
    **/
    orderBy?: Enumerable<OneOptionalOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for OneOptionals.
    **/
    cursor?: OneOptionalWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OneOptionals 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\` OneOptionals.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of OneOptionals.
    **/
    distinct?: Enumerable<OneOptionalScalarFieldEnum>
  }


  /**
   * OneOptional findMany
   */
  export type FindManyOneOptionalArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * Filter, which OneOptionals to fetch.
    **/
    where?: OneOptionalWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OneOptionals to fetch.
    **/
    orderBy?: Enumerable<OneOptionalOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing OneOptionals.
    **/
    cursor?: OneOptionalWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OneOptionals 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\` OneOptionals.
    **/
    skip?: number
    distinct?: Enumerable<OneOptionalScalarFieldEnum>
  }


  /**
   * OneOptional create
   */
  export type OneOptionalCreateArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * The data needed to create a OneOptional.
    **/
    data: XOR<OneOptionalUncheckedCreateInput, OneOptionalCreateInput>
  }


  /**
   * OneOptional update
   */
  export type OneOptionalUpdateArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * The data needed to update a OneOptional.
    **/
    data: XOR<OneOptionalUncheckedUpdateInput, OneOptionalUpdateInput>
    /**
     * Choose, which OneOptional to update.
    **/
    where: OneOptionalWhereUniqueInput
  }


  /**
   * OneOptional updateMany
   */
  export type OneOptionalUpdateManyArgs = {
    data: XOR<OneOptionalUncheckedUpdateManyInput, OneOptionalUpdateManyMutationInput>
    where?: OneOptionalWhereInput
  }


  /**
   * OneOptional upsert
   */
  export type OneOptionalUpsertArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * The filter to search for the OneOptional to update in case it exists.
    **/
    where: OneOptionalWhereUniqueInput
    /**
     * In case the OneOptional found by the \`where\` argument doesn't exist, create a new OneOptional with this data.
    **/
    create: XOR<OneOptionalUncheckedCreateInput, OneOptionalCreateInput>
    /**
     * In case the OneOptional was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<OneOptionalUncheckedUpdateInput, OneOptionalUpdateInput>
  }


  /**
   * OneOptional delete
   */
  export type OneOptionalDeleteArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
    /**
     * Filter which OneOptional to delete.
    **/
    where: OneOptionalWhereUniqueInput
  }


  /**
   * OneOptional deleteMany
   */
  export type OneOptionalDeleteManyArgs = {
    where?: OneOptionalWhereInput
  }


  /**
   * OneOptional without action
   */
  export type OneOptionalArgs = {
    /**
     * Select specific fields to fetch from the OneOptional
    **/
    select?: OneOptionalSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OneOptionalInclude | null
  }



  /**
   * Model ManyRequired
   */


  export type AggregateManyRequired = {
    count: number | null
    avg: ManyRequiredAvgAggregateOutputType | null
    sum: ManyRequiredSumAggregateOutputType | null
    min: ManyRequiredMinAggregateOutputType | null
    max: ManyRequiredMaxAggregateOutputType | null
  }

  export type ManyRequiredAvgAggregateOutputType = {
    id: number
    oneOptionalId: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type ManyRequiredSumAggregateOutputType = {
    id: number
    oneOptionalId: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type ManyRequiredMinAggregateOutputType = {
    id: number
    oneOptionalId: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type ManyRequiredMaxAggregateOutputType = {
    id: number
    oneOptionalId: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type ManyRequiredCountAggregateOutputType = {
    id: number
    oneOptionalId: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type ManyRequiredAvgAggregateInputType = {
    id?: true
    oneOptionalId?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type ManyRequiredSumAggregateInputType = {
    id?: true
    oneOptionalId?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type ManyRequiredMinAggregateInputType = {
    id?: true
    oneOptionalId?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type ManyRequiredMaxAggregateInputType = {
    id?: true
    oneOptionalId?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type ManyRequiredCountAggregateInputType = {
    id?: true
    oneOptionalId?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateManyRequiredArgs = {
    /**
     * Filter which ManyRequired to aggregate.
    **/
    where?: ManyRequiredWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of ManyRequireds to fetch.
    **/
    orderBy?: Enumerable<ManyRequiredOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: ManyRequiredWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` ManyRequireds 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\` ManyRequireds.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ManyRequireds
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: ManyRequiredAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: ManyRequiredSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: ManyRequiredMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: ManyRequiredMaxAggregateInputType
  }

  export type GetManyRequiredAggregateType<T extends AggregateManyRequiredArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetManyRequiredAggregateScalarType<T[P]>
  }

  export type GetManyRequiredAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof ManyRequiredAvgAggregateOutputType ? ManyRequiredAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByManyRequiredArgs = {
    where?: ManyRequiredWhereInput
    orderBy?: Enumerable<ManyRequiredOrderByInput>
    by: Array<ManyRequiredScalarFieldEnum>
    take?: number
    skip?: number
    count?: ManyRequiredCountAggregateInputType
    avg?: ManyRequiredAvgAggregateInputType
    sum?: ManyRequiredSumAggregateInputType
    min?: ManyRequiredMinAggregateInputType
    max?: ManyRequiredMaxAggregateInputType
  }


  export type ManyRequiredGroupByOutputType = {
    id: number | null
    oneOptionalId: number | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: ManyRequiredCountAggregateOutputType | null
    avg: ManyRequiredAvgAggregateOutputType | null
    sum: ManyRequiredSumAggregateOutputType | null
    min: ManyRequiredMinAggregateOutputType | null
    max: ManyRequiredMaxAggregateOutputType | null
  }

  type GetManyRequiredGroupByPayload<T extends GroupByManyRequiredArgs> = Promise<
    PickArray<ManyRequiredGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof ManyRequiredGroupByOutputType))]: GetScalarType<T[P], ManyRequiredGroupByOutputType[P]>
    }
  >
    

  export type ManyRequiredSelect = {
    id?: boolean
    one?: boolean | OneOptionalArgs
    oneOptionalId?: boolean
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
  }

  export type ManyRequiredInclude = {
    one?: boolean | OneOptionalArgs
  }

  export type ManyRequiredGetPayload<
    S extends boolean | null | undefined | ManyRequiredArgs,
    U = keyof S
      > = S extends true
        ? ManyRequired
    : S extends undefined
    ? never
    : S extends ManyRequiredArgs | FindManyManyRequiredArgs
    ?'include' extends U
    ? ManyRequired  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'one'
        ? OneOptionalGetPayload<S['include'][P]> | null : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof ManyRequired ?ManyRequired [P]
  : 
          P extends 'one'
        ? OneOptionalGetPayload<S['select'][P]> | null : never
  } 
    : ManyRequired
  : ManyRequired


  export interface ManyRequiredDelegate {
    /**
     * Find zero or one ManyRequired that matches the filter.
     * @param {FindUniqueManyRequiredArgs} args - Arguments to find a ManyRequired
     * @example
     * // Get one ManyRequired
     * const manyRequired = await prisma.manyRequired.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueManyRequiredArgs>(
      args: Subset<T, FindUniqueManyRequiredArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired | null>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T> | null>>

    /**
     * Find the first ManyRequired that matches the filter.
     * @param {FindFirstManyRequiredArgs} args - Arguments to find a ManyRequired
     * @example
     * // Get one ManyRequired
     * const manyRequired = await prisma.manyRequired.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstManyRequiredArgs>(
      args?: Subset<T, FindFirstManyRequiredArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired | null>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T> | null>>

    /**
     * Find zero or more ManyRequireds that matches the filter.
     * @param {FindManyManyRequiredArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ManyRequireds
     * const manyRequireds = await prisma.manyRequired.findMany()
     * 
     * // Get first 10 ManyRequireds
     * const manyRequireds = await prisma.manyRequired.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const manyRequiredWithIdOnly = await prisma.manyRequired.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyManyRequiredArgs>(
      args?: Subset<T, FindManyManyRequiredArgs>
    ): CheckSelect<T, Promise<Array<ManyRequired>>, Promise<Array<ManyRequiredGetPayload<T>>>>

    /**
     * Create a ManyRequired.
     * @param {ManyRequiredCreateArgs} args - Arguments to create a ManyRequired.
     * @example
     * // Create one ManyRequired
     * const ManyRequired = await prisma.manyRequired.create({
     *   data: {
     *     // ... data to create a ManyRequired
     *   }
     * })
     * 
    **/
    create<T extends ManyRequiredCreateArgs>(
      args: Subset<T, ManyRequiredCreateArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T>>>

    /**
     * Delete a ManyRequired.
     * @param {ManyRequiredDeleteArgs} args - Arguments to delete one ManyRequired.
     * @example
     * // Delete one ManyRequired
     * const ManyRequired = await prisma.manyRequired.delete({
     *   where: {
     *     // ... filter to delete one ManyRequired
     *   }
     * })
     * 
    **/
    delete<T extends ManyRequiredDeleteArgs>(
      args: Subset<T, ManyRequiredDeleteArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T>>>

    /**
     * Update one ManyRequired.
     * @param {ManyRequiredUpdateArgs} args - Arguments to update one ManyRequired.
     * @example
     * // Update one ManyRequired
     * const manyRequired = await prisma.manyRequired.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ManyRequiredUpdateArgs>(
      args: Subset<T, ManyRequiredUpdateArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T>>>

    /**
     * Delete zero or more ManyRequireds.
     * @param {ManyRequiredDeleteManyArgs} args - Arguments to filter ManyRequireds to delete.
     * @example
     * // Delete a few ManyRequireds
     * const { count } = await prisma.manyRequired.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends ManyRequiredDeleteManyArgs>(
      args?: Subset<T, ManyRequiredDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more ManyRequireds.
     * @param {ManyRequiredUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many ManyRequireds
     * const manyRequired = await prisma.manyRequired.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends ManyRequiredUpdateManyArgs>(
      args: Subset<T, ManyRequiredUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one ManyRequired.
     * @param {ManyRequiredUpsertArgs} args - Arguments to update or create a ManyRequired.
     * @example
     * // Update or create a ManyRequired
     * const manyRequired = await prisma.manyRequired.upsert({
     *   create: {
     *     // ... data to create a ManyRequired
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the ManyRequired we want to update
     *   }
     * })
    **/
    upsert<T extends ManyRequiredUpsertArgs>(
      args: Subset<T, ManyRequiredUpsertArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T>>>

    /**
     * Find zero or one ManyRequired that matches the filter.
     * @param {FindUniqueManyRequiredArgs} args - Arguments to find a ManyRequired
     * @deprecated This will be deprecated please use prisma.manyRequired.findUnique
     * @example
     * // Get one ManyRequired
     * const manyRequired = await prisma.manyRequired.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueManyRequiredArgs>(
      args: Subset<T, FindUniqueManyRequiredArgs>
    ): CheckSelect<T, Prisma__ManyRequiredClient<ManyRequired | null>, Prisma__ManyRequiredClient<ManyRequiredGetPayload<T> | null>>

    /**
     * Count the number of ManyRequireds.
     * @param {FindManyManyRequiredArgs} args - Arguments to filter ManyRequireds to count.
     * @example
     * // Count the number of ManyRequireds
     * const count = await prisma.manyRequired.count({
     *   where: {
     *     // ... the filter for the ManyRequireds we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyManyRequiredArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a ManyRequired.
     * @param {AggregateManyRequiredArgs} 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 AggregateManyRequiredArgs>(args: Subset<T, AggregateManyRequiredArgs>): Promise<GetManyRequiredAggregateType<T>>

    /**
     * Group by ManyRequired.
     * @param {GroupByManyRequiredArgs} 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 GroupByManyRequiredArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByManyRequiredArgs['orderBy'] }
        : { orderBy?: GroupByManyRequiredArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByManyRequiredArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetManyRequiredGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for ManyRequired.
   * 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 class Prisma__ManyRequiredClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    one<T extends OneOptionalArgs = {}>(args?: Subset<T, OneOptionalArgs>): CheckSelect<T, Prisma__OneOptionalClient<OneOptional | null>, Prisma__OneOptionalClient<OneOptionalGetPayload<T> | null>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * ManyRequired findUnique
   */
  export type FindUniqueManyRequiredArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * Filter, which ManyRequired to fetch.
    **/
    where: ManyRequiredWhereUniqueInput
  }


  /**
   * ManyRequired findFirst
   */
  export type FindFirstManyRequiredArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * Filter, which ManyRequired to fetch.
    **/
    where?: ManyRequiredWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of ManyRequireds to fetch.
    **/
    orderBy?: Enumerable<ManyRequiredOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ManyRequireds.
    **/
    cursor?: ManyRequiredWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` ManyRequireds 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\` ManyRequireds.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of ManyRequireds.
    **/
    distinct?: Enumerable<ManyRequiredScalarFieldEnum>
  }


  /**
   * ManyRequired findMany
   */
  export type FindManyManyRequiredArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * Filter, which ManyRequireds to fetch.
    **/
    where?: ManyRequiredWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of ManyRequireds to fetch.
    **/
    orderBy?: Enumerable<ManyRequiredOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ManyRequireds.
    **/
    cursor?: ManyRequiredWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` ManyRequireds 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\` ManyRequireds.
    **/
    skip?: number
    distinct?: Enumerable<ManyRequiredScalarFieldEnum>
  }


  /**
   * ManyRequired create
   */
  export type ManyRequiredCreateArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * The data needed to create a ManyRequired.
    **/
    data: XOR<ManyRequiredUncheckedCreateInput, ManyRequiredCreateInput>
  }


  /**
   * ManyRequired update
   */
  export type ManyRequiredUpdateArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * The data needed to update a ManyRequired.
    **/
    data: XOR<ManyRequiredUncheckedUpdateInput, ManyRequiredUpdateInput>
    /**
     * Choose, which ManyRequired to update.
    **/
    where: ManyRequiredWhereUniqueInput
  }


  /**
   * ManyRequired updateMany
   */
  export type ManyRequiredUpdateManyArgs = {
    data: XOR<ManyRequiredUncheckedUpdateManyInput, ManyRequiredUpdateManyMutationInput>
    where?: ManyRequiredWhereInput
  }


  /**
   * ManyRequired upsert
   */
  export type ManyRequiredUpsertArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * The filter to search for the ManyRequired to update in case it exists.
    **/
    where: ManyRequiredWhereUniqueInput
    /**
     * In case the ManyRequired found by the \`where\` argument doesn't exist, create a new ManyRequired with this data.
    **/
    create: XOR<ManyRequiredUncheckedCreateInput, ManyRequiredCreateInput>
    /**
     * In case the ManyRequired was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<ManyRequiredUncheckedUpdateInput, ManyRequiredUpdateInput>
  }


  /**
   * ManyRequired delete
   */
  export type ManyRequiredDeleteArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
    /**
     * Filter which ManyRequired to delete.
    **/
    where: ManyRequiredWhereUniqueInput
  }


  /**
   * ManyRequired deleteMany
   */
  export type ManyRequiredDeleteManyArgs = {
    where?: ManyRequiredWhereInput
  }


  /**
   * ManyRequired without action
   */
  export type ManyRequiredArgs = {
    /**
     * Select specific fields to fetch from the ManyRequired
    **/
    select?: ManyRequiredSelect | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: ManyRequiredInclude | null
  }



  /**
   * Model OptionalSide1
   */


  export type AggregateOptionalSide1 = {
    count: number | null
    avg: OptionalSide1AvgAggregateOutputType | null
    sum: OptionalSide1SumAggregateOutputType | null
    min: OptionalSide1MinAggregateOutputType | null
    max: OptionalSide1MaxAggregateOutputType | null
  }

  export type OptionalSide1AvgAggregateOutputType = {
    id: number
    optionalSide2Id: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type OptionalSide1SumAggregateOutputType = {
    id: number
    optionalSide2Id: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type OptionalSide1MinAggregateOutputType = {
    id: number
    optionalSide2Id: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type OptionalSide1MaxAggregateOutputType = {
    id: number
    optionalSide2Id: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type OptionalSide1CountAggregateOutputType = {
    id: number
    optionalSide2Id: number | null
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type OptionalSide1AvgAggregateInputType = {
    id?: true
    optionalSide2Id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type OptionalSide1SumAggregateInputType = {
    id?: true
    optionalSide2Id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type OptionalSide1MinAggregateInputType = {
    id?: true
    optionalSide2Id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type OptionalSide1MaxAggregateInputType = {
    id?: true
    optionalSide2Id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type OptionalSide1CountAggregateInputType = {
    id?: true
    optionalSide2Id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateOptionalSide1Args = {
    /**
     * Filter which OptionalSide1 to aggregate.
    **/
    where?: OptionalSide1WhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OptionalSide1s to fetch.
    **/
    orderBy?: Enumerable<OptionalSide1OrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: OptionalSide1WhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OptionalSide1s 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\` OptionalSide1s.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned OptionalSide1s
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: OptionalSide1AvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: OptionalSide1SumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: OptionalSide1MinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: OptionalSide1MaxAggregateInputType
  }

  export type GetOptionalSide1AggregateType<T extends AggregateOptionalSide1Args> = {
    [P in keyof T]: P extends 'count' ? number : GetOptionalSide1AggregateScalarType<T[P]>
  }

  export type GetOptionalSide1AggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof OptionalSide1AvgAggregateOutputType ? OptionalSide1AvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByOptionalSide1Args = {
    where?: OptionalSide1WhereInput
    orderBy?: Enumerable<OptionalSide1OrderByInput>
    by: Array<OptionalSide1ScalarFieldEnum>
    take?: number
    skip?: number
    count?: OptionalSide1CountAggregateInputType
    avg?: OptionalSide1AvgAggregateInputType
    sum?: OptionalSide1SumAggregateInputType
    min?: OptionalSide1MinAggregateInputType
    max?: OptionalSide1MaxAggregateInputType
  }


  export type OptionalSide1GroupByOutputType = {
    id: number | null
    optionalSide2Id: number | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: OptionalSide1CountAggregateOutputType | null
    avg: OptionalSide1AvgAggregateOutputType | null
    sum: OptionalSide1SumAggregateOutputType | null
    min: OptionalSide1MinAggregateOutputType | null
    max: OptionalSide1MaxAggregateOutputType | null
  }

  type GetOptionalSide1GroupByPayload<T extends GroupByOptionalSide1Args> = Promise<
    PickArray<OptionalSide1GroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof OptionalSide1GroupByOutputType))]: GetScalarType<T[P], OptionalSide1GroupByOutputType[P]>
    }
  >
    

  export type OptionalSide1Select = {
    id?: boolean
    opti?: boolean | OptionalSide2Args
    optionalSide2Id?: boolean
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
  }

  export type OptionalSide1Include = {
    opti?: boolean | OptionalSide2Args
  }

  export type OptionalSide1GetPayload<
    S extends boolean | null | undefined | OptionalSide1Args,
    U = keyof S
      > = S extends true
        ? OptionalSide1
    : S extends undefined
    ? never
    : S extends OptionalSide1Args | FindManyOptionalSide1Args
    ?'include' extends U
    ? OptionalSide1  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'opti'
        ? OptionalSide2GetPayload<S['include'][P]> | null : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof OptionalSide1 ?OptionalSide1 [P]
  : 
          P extends 'opti'
        ? OptionalSide2GetPayload<S['select'][P]> | null : never
  } 
    : OptionalSide1
  : OptionalSide1


  export interface OptionalSide1Delegate {
    /**
     * Find zero or one OptionalSide1 that matches the filter.
     * @param {FindUniqueOptionalSide1Args} args - Arguments to find a OptionalSide1
     * @example
     * // Get one OptionalSide1
     * const optionalSide1 = await prisma.optionalSide1.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueOptionalSide1Args>(
      args: Subset<T, FindUniqueOptionalSide1Args>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1 | null>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T> | null>>

    /**
     * Find the first OptionalSide1 that matches the filter.
     * @param {FindFirstOptionalSide1Args} args - Arguments to find a OptionalSide1
     * @example
     * // Get one OptionalSide1
     * const optionalSide1 = await prisma.optionalSide1.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstOptionalSide1Args>(
      args?: Subset<T, FindFirstOptionalSide1Args>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1 | null>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T> | null>>

    /**
     * Find zero or more OptionalSide1s that matches the filter.
     * @param {FindManyOptionalSide1Args=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all OptionalSide1s
     * const optionalSide1s = await prisma.optionalSide1.findMany()
     * 
     * // Get first 10 OptionalSide1s
     * const optionalSide1s = await prisma.optionalSide1.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const optionalSide1WithIdOnly = await prisma.optionalSide1.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyOptionalSide1Args>(
      args?: Subset<T, FindManyOptionalSide1Args>
    ): CheckSelect<T, Promise<Array<OptionalSide1>>, Promise<Array<OptionalSide1GetPayload<T>>>>

    /**
     * Create a OptionalSide1.
     * @param {OptionalSide1CreateArgs} args - Arguments to create a OptionalSide1.
     * @example
     * // Create one OptionalSide1
     * const OptionalSide1 = await prisma.optionalSide1.create({
     *   data: {
     *     // ... data to create a OptionalSide1
     *   }
     * })
     * 
    **/
    create<T extends OptionalSide1CreateArgs>(
      args: Subset<T, OptionalSide1CreateArgs>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T>>>

    /**
     * Delete a OptionalSide1.
     * @param {OptionalSide1DeleteArgs} args - Arguments to delete one OptionalSide1.
     * @example
     * // Delete one OptionalSide1
     * const OptionalSide1 = await prisma.optionalSide1.delete({
     *   where: {
     *     // ... filter to delete one OptionalSide1
     *   }
     * })
     * 
    **/
    delete<T extends OptionalSide1DeleteArgs>(
      args: Subset<T, OptionalSide1DeleteArgs>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T>>>

    /**
     * Update one OptionalSide1.
     * @param {OptionalSide1UpdateArgs} args - Arguments to update one OptionalSide1.
     * @example
     * // Update one OptionalSide1
     * const optionalSide1 = await prisma.optionalSide1.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends OptionalSide1UpdateArgs>(
      args: Subset<T, OptionalSide1UpdateArgs>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T>>>

    /**
     * Delete zero or more OptionalSide1s.
     * @param {OptionalSide1DeleteManyArgs} args - Arguments to filter OptionalSide1s to delete.
     * @example
     * // Delete a few OptionalSide1s
     * const { count } = await prisma.optionalSide1.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends OptionalSide1DeleteManyArgs>(
      args?: Subset<T, OptionalSide1DeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more OptionalSide1s.
     * @param {OptionalSide1UpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many OptionalSide1s
     * const optionalSide1 = await prisma.optionalSide1.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends OptionalSide1UpdateManyArgs>(
      args: Subset<T, OptionalSide1UpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one OptionalSide1.
     * @param {OptionalSide1UpsertArgs} args - Arguments to update or create a OptionalSide1.
     * @example
     * // Update or create a OptionalSide1
     * const optionalSide1 = await prisma.optionalSide1.upsert({
     *   create: {
     *     // ... data to create a OptionalSide1
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the OptionalSide1 we want to update
     *   }
     * })
    **/
    upsert<T extends OptionalSide1UpsertArgs>(
      args: Subset<T, OptionalSide1UpsertArgs>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T>>>

    /**
     * Find zero or one OptionalSide1 that matches the filter.
     * @param {FindUniqueOptionalSide1Args} args - Arguments to find a OptionalSide1
     * @deprecated This will be deprecated please use prisma.optionalSide1.findUnique
     * @example
     * // Get one OptionalSide1
     * const optionalSide1 = await prisma.optionalSide1.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueOptionalSide1Args>(
      args: Subset<T, FindUniqueOptionalSide1Args>
    ): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1 | null>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T> | null>>

    /**
     * Count the number of OptionalSide1s.
     * @param {FindManyOptionalSide1Args} args - Arguments to filter OptionalSide1s to count.
     * @example
     * // Count the number of OptionalSide1s
     * const count = await prisma.optionalSide1.count({
     *   where: {
     *     // ... the filter for the OptionalSide1s we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyOptionalSide1Args, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a OptionalSide1.
     * @param {AggregateOptionalSide1Args} 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 AggregateOptionalSide1Args>(args: Subset<T, AggregateOptionalSide1Args>): Promise<GetOptionalSide1AggregateType<T>>

    /**
     * Group by OptionalSide1.
     * @param {GroupByOptionalSide1Args} 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 GroupByOptionalSide1Args,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByOptionalSide1Args['orderBy'] }
        : { orderBy?: GroupByOptionalSide1Args['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByOptionalSide1Args, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetOptionalSide1GroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for OptionalSide1.
   * 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 class Prisma__OptionalSide1Client<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    opti<T extends OptionalSide2Args = {}>(args?: Subset<T, OptionalSide2Args>): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2 | null>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T> | null>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * OptionalSide1 findUnique
   */
  export type FindUniqueOptionalSide1Args = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * Filter, which OptionalSide1 to fetch.
    **/
    where: OptionalSide1WhereUniqueInput
  }


  /**
   * OptionalSide1 findFirst
   */
  export type FindFirstOptionalSide1Args = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * Filter, which OptionalSide1 to fetch.
    **/
    where?: OptionalSide1WhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OptionalSide1s to fetch.
    **/
    orderBy?: Enumerable<OptionalSide1OrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for OptionalSide1s.
    **/
    cursor?: OptionalSide1WhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OptionalSide1s 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\` OptionalSide1s.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of OptionalSide1s.
    **/
    distinct?: Enumerable<OptionalSide1ScalarFieldEnum>
  }


  /**
   * OptionalSide1 findMany
   */
  export type FindManyOptionalSide1Args = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * Filter, which OptionalSide1s to fetch.
    **/
    where?: OptionalSide1WhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OptionalSide1s to fetch.
    **/
    orderBy?: Enumerable<OptionalSide1OrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing OptionalSide1s.
    **/
    cursor?: OptionalSide1WhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OptionalSide1s 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\` OptionalSide1s.
    **/
    skip?: number
    distinct?: Enumerable<OptionalSide1ScalarFieldEnum>
  }


  /**
   * OptionalSide1 create
   */
  export type OptionalSide1CreateArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * The data needed to create a OptionalSide1.
    **/
    data: XOR<OptionalSide1UncheckedCreateInput, OptionalSide1CreateInput>
  }


  /**
   * OptionalSide1 update
   */
  export type OptionalSide1UpdateArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * The data needed to update a OptionalSide1.
    **/
    data: XOR<OptionalSide1UncheckedUpdateInput, OptionalSide1UpdateInput>
    /**
     * Choose, which OptionalSide1 to update.
    **/
    where: OptionalSide1WhereUniqueInput
  }


  /**
   * OptionalSide1 updateMany
   */
  export type OptionalSide1UpdateManyArgs = {
    data: XOR<OptionalSide1UncheckedUpdateManyInput, OptionalSide1UpdateManyMutationInput>
    where?: OptionalSide1WhereInput
  }


  /**
   * OptionalSide1 upsert
   */
  export type OptionalSide1UpsertArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * The filter to search for the OptionalSide1 to update in case it exists.
    **/
    where: OptionalSide1WhereUniqueInput
    /**
     * In case the OptionalSide1 found by the \`where\` argument doesn't exist, create a new OptionalSide1 with this data.
    **/
    create: XOR<OptionalSide1UncheckedCreateInput, OptionalSide1CreateInput>
    /**
     * In case the OptionalSide1 was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<OptionalSide1UncheckedUpdateInput, OptionalSide1UpdateInput>
  }


  /**
   * OptionalSide1 delete
   */
  export type OptionalSide1DeleteArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
    /**
     * Filter which OptionalSide1 to delete.
    **/
    where: OptionalSide1WhereUniqueInput
  }


  /**
   * OptionalSide1 deleteMany
   */
  export type OptionalSide1DeleteManyArgs = {
    where?: OptionalSide1WhereInput
  }


  /**
   * OptionalSide1 without action
   */
  export type OptionalSide1Args = {
    /**
     * Select specific fields to fetch from the OptionalSide1
    **/
    select?: OptionalSide1Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide1Include | null
  }



  /**
   * Model OptionalSide2
   */


  export type AggregateOptionalSide2 = {
    count: number | null
    avg: OptionalSide2AvgAggregateOutputType | null
    sum: OptionalSide2SumAggregateOutputType | null
    min: OptionalSide2MinAggregateOutputType | null
    max: OptionalSide2MaxAggregateOutputType | null
  }

  export type OptionalSide2AvgAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type OptionalSide2SumAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
  }

  export type OptionalSide2MinAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type OptionalSide2MaxAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
  }

  export type OptionalSide2CountAggregateOutputType = {
    id: number
    int: number
    optionalInt: number | null
    float: number
    optionalFloat: number | null
    string: number | null
    optionalString: number | null
    json: number | null
    optionalJson: number | null
    enum: number | null
    optionalEnum: number | null
    boolean: number | null
    optionalBoolean: number | null
    _all: number
  }


  export type OptionalSide2AvgAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type OptionalSide2SumAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
  }

  export type OptionalSide2MinAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type OptionalSide2MaxAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
  }

  export type OptionalSide2CountAggregateInputType = {
    id?: true
    int?: true
    optionalInt?: true
    float?: true
    optionalFloat?: true
    string?: true
    optionalString?: true
    json?: true
    optionalJson?: true
    enum?: true
    optionalEnum?: true
    boolean?: true
    optionalBoolean?: true
    _all?: true
  }

  export type AggregateOptionalSide2Args = {
    /**
     * Filter which OptionalSide2 to aggregate.
    **/
    where?: OptionalSide2WhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OptionalSide2s to fetch.
    **/
    orderBy?: Enumerable<OptionalSide2OrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: OptionalSide2WhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OptionalSide2s 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\` OptionalSide2s.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned OptionalSide2s
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: OptionalSide2AvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: OptionalSide2SumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: OptionalSide2MinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: OptionalSide2MaxAggregateInputType
  }

  export type GetOptionalSide2AggregateType<T extends AggregateOptionalSide2Args> = {
    [P in keyof T]: P extends 'count' ? number : GetOptionalSide2AggregateScalarType<T[P]>
  }

  export type GetOptionalSide2AggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof OptionalSide2AvgAggregateOutputType ? OptionalSide2AvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByOptionalSide2Args = {
    where?: OptionalSide2WhereInput
    orderBy?: Enumerable<OptionalSide2OrderByInput>
    by: Array<OptionalSide2ScalarFieldEnum>
    take?: number
    skip?: number
    count?: OptionalSide2CountAggregateInputType
    avg?: OptionalSide2AvgAggregateInputType
    sum?: OptionalSide2SumAggregateInputType
    min?: OptionalSide2MinAggregateInputType
    max?: OptionalSide2MaxAggregateInputType
  }


  export type OptionalSide2GroupByOutputType = {
    id: number | null
    int: number | null
    optionalInt: number | null
    float: number | null
    optionalFloat: number | null
    string: string | null
    optionalString: string | null
    json: JsonValue | null
    optionalJson: JsonValue | null
    enum: ABeautifulEnum | null
    optionalEnum: ABeautifulEnum | null
    boolean: boolean | null
    optionalBoolean: boolean | null
    count: OptionalSide2CountAggregateOutputType | null
    avg: OptionalSide2AvgAggregateOutputType | null
    sum: OptionalSide2SumAggregateOutputType | null
    min: OptionalSide2MinAggregateOutputType | null
    max: OptionalSide2MaxAggregateOutputType | null
  }

  type GetOptionalSide2GroupByPayload<T extends GroupByOptionalSide2Args> = Promise<
    PickArray<OptionalSide2GroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof OptionalSide2GroupByOutputType))]: GetScalarType<T[P], OptionalSide2GroupByOutputType[P]>
    }
  >
    

  export type OptionalSide2Select = {
    id?: boolean
    opti?: boolean | OptionalSide1Args
    int?: boolean
    optionalInt?: boolean
    float?: boolean
    optionalFloat?: boolean
    string?: boolean
    optionalString?: boolean
    json?: boolean
    optionalJson?: boolean
    enum?: boolean
    optionalEnum?: boolean
    boolean?: boolean
    optionalBoolean?: boolean
  }

  export type OptionalSide2Include = {
    opti?: boolean | OptionalSide1Args
  }

  export type OptionalSide2GetPayload<
    S extends boolean | null | undefined | OptionalSide2Args,
    U = keyof S
      > = S extends true
        ? OptionalSide2
    : S extends undefined
    ? never
    : S extends OptionalSide2Args | FindManyOptionalSide2Args
    ?'include' extends U
    ? OptionalSide2  & {
    [P in TrueKeys<S['include']>]: 
          P extends 'opti'
        ? OptionalSide1GetPayload<S['include'][P]> | null : never
  } 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof OptionalSide2 ?OptionalSide2 [P]
  : 
          P extends 'opti'
        ? OptionalSide1GetPayload<S['select'][P]> | null : never
  } 
    : OptionalSide2
  : OptionalSide2


  export interface OptionalSide2Delegate {
    /**
     * Find zero or one OptionalSide2 that matches the filter.
     * @param {FindUniqueOptionalSide2Args} args - Arguments to find a OptionalSide2
     * @example
     * // Get one OptionalSide2
     * const optionalSide2 = await prisma.optionalSide2.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueOptionalSide2Args>(
      args: Subset<T, FindUniqueOptionalSide2Args>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2 | null>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T> | null>>

    /**
     * Find the first OptionalSide2 that matches the filter.
     * @param {FindFirstOptionalSide2Args} args - Arguments to find a OptionalSide2
     * @example
     * // Get one OptionalSide2
     * const optionalSide2 = await prisma.optionalSide2.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstOptionalSide2Args>(
      args?: Subset<T, FindFirstOptionalSide2Args>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2 | null>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T> | null>>

    /**
     * Find zero or more OptionalSide2s that matches the filter.
     * @param {FindManyOptionalSide2Args=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all OptionalSide2s
     * const optionalSide2s = await prisma.optionalSide2.findMany()
     * 
     * // Get first 10 OptionalSide2s
     * const optionalSide2s = await prisma.optionalSide2.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const optionalSide2WithIdOnly = await prisma.optionalSide2.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyOptionalSide2Args>(
      args?: Subset<T, FindManyOptionalSide2Args>
    ): CheckSelect<T, Promise<Array<OptionalSide2>>, Promise<Array<OptionalSide2GetPayload<T>>>>

    /**
     * Create a OptionalSide2.
     * @param {OptionalSide2CreateArgs} args - Arguments to create a OptionalSide2.
     * @example
     * // Create one OptionalSide2
     * const OptionalSide2 = await prisma.optionalSide2.create({
     *   data: {
     *     // ... data to create a OptionalSide2
     *   }
     * })
     * 
    **/
    create<T extends OptionalSide2CreateArgs>(
      args: Subset<T, OptionalSide2CreateArgs>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T>>>

    /**
     * Delete a OptionalSide2.
     * @param {OptionalSide2DeleteArgs} args - Arguments to delete one OptionalSide2.
     * @example
     * // Delete one OptionalSide2
     * const OptionalSide2 = await prisma.optionalSide2.delete({
     *   where: {
     *     // ... filter to delete one OptionalSide2
     *   }
     * })
     * 
    **/
    delete<T extends OptionalSide2DeleteArgs>(
      args: Subset<T, OptionalSide2DeleteArgs>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T>>>

    /**
     * Update one OptionalSide2.
     * @param {OptionalSide2UpdateArgs} args - Arguments to update one OptionalSide2.
     * @example
     * // Update one OptionalSide2
     * const optionalSide2 = await prisma.optionalSide2.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends OptionalSide2UpdateArgs>(
      args: Subset<T, OptionalSide2UpdateArgs>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T>>>

    /**
     * Delete zero or more OptionalSide2s.
     * @param {OptionalSide2DeleteManyArgs} args - Arguments to filter OptionalSide2s to delete.
     * @example
     * // Delete a few OptionalSide2s
     * const { count } = await prisma.optionalSide2.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends OptionalSide2DeleteManyArgs>(
      args?: Subset<T, OptionalSide2DeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more OptionalSide2s.
     * @param {OptionalSide2UpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many OptionalSide2s
     * const optionalSide2 = await prisma.optionalSide2.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends OptionalSide2UpdateManyArgs>(
      args: Subset<T, OptionalSide2UpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one OptionalSide2.
     * @param {OptionalSide2UpsertArgs} args - Arguments to update or create a OptionalSide2.
     * @example
     * // Update or create a OptionalSide2
     * const optionalSide2 = await prisma.optionalSide2.upsert({
     *   create: {
     *     // ... data to create a OptionalSide2
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the OptionalSide2 we want to update
     *   }
     * })
    **/
    upsert<T extends OptionalSide2UpsertArgs>(
      args: Subset<T, OptionalSide2UpsertArgs>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T>>>

    /**
     * Find zero or one OptionalSide2 that matches the filter.
     * @param {FindUniqueOptionalSide2Args} args - Arguments to find a OptionalSide2
     * @deprecated This will be deprecated please use prisma.optionalSide2.findUnique
     * @example
     * // Get one OptionalSide2
     * const optionalSide2 = await prisma.optionalSide2.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueOptionalSide2Args>(
      args: Subset<T, FindUniqueOptionalSide2Args>
    ): CheckSelect<T, Prisma__OptionalSide2Client<OptionalSide2 | null>, Prisma__OptionalSide2Client<OptionalSide2GetPayload<T> | null>>

    /**
     * Count the number of OptionalSide2s.
     * @param {FindManyOptionalSide2Args} args - Arguments to filter OptionalSide2s to count.
     * @example
     * // Count the number of OptionalSide2s
     * const count = await prisma.optionalSide2.count({
     *   where: {
     *     // ... the filter for the OptionalSide2s we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyOptionalSide2Args, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a OptionalSide2.
     * @param {AggregateOptionalSide2Args} 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 AggregateOptionalSide2Args>(args: Subset<T, AggregateOptionalSide2Args>): Promise<GetOptionalSide2AggregateType<T>>

    /**
     * Group by OptionalSide2.
     * @param {GroupByOptionalSide2Args} 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 GroupByOptionalSide2Args,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByOptionalSide2Args['orderBy'] }
        : { orderBy?: GroupByOptionalSide2Args['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByOptionalSide2Args, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetOptionalSide2GroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for OptionalSide2.
   * 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 class Prisma__OptionalSide2Client<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';

    opti<T extends OptionalSide1Args = {}>(args?: Subset<T, OptionalSide1Args>): CheckSelect<T, Prisma__OptionalSide1Client<OptionalSide1 | null>, Prisma__OptionalSide1Client<OptionalSide1GetPayload<T> | null>>;

    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * OptionalSide2 findUnique
   */
  export type FindUniqueOptionalSide2Args = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * Filter, which OptionalSide2 to fetch.
    **/
    where: OptionalSide2WhereUniqueInput
  }


  /**
   * OptionalSide2 findFirst
   */
  export type FindFirstOptionalSide2Args = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * Filter, which OptionalSide2 to fetch.
    **/
    where?: OptionalSide2WhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OptionalSide2s to fetch.
    **/
    orderBy?: Enumerable<OptionalSide2OrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for OptionalSide2s.
    **/
    cursor?: OptionalSide2WhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OptionalSide2s 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\` OptionalSide2s.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of OptionalSide2s.
    **/
    distinct?: Enumerable<OptionalSide2ScalarFieldEnum>
  }


  /**
   * OptionalSide2 findMany
   */
  export type FindManyOptionalSide2Args = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * Filter, which OptionalSide2s to fetch.
    **/
    where?: OptionalSide2WhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of OptionalSide2s to fetch.
    **/
    orderBy?: Enumerable<OptionalSide2OrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing OptionalSide2s.
    **/
    cursor?: OptionalSide2WhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` OptionalSide2s 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\` OptionalSide2s.
    **/
    skip?: number
    distinct?: Enumerable<OptionalSide2ScalarFieldEnum>
  }


  /**
   * OptionalSide2 create
   */
  export type OptionalSide2CreateArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * The data needed to create a OptionalSide2.
    **/
    data: XOR<OptionalSide2UncheckedCreateInput, OptionalSide2CreateInput>
  }


  /**
   * OptionalSide2 update
   */
  export type OptionalSide2UpdateArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * The data needed to update a OptionalSide2.
    **/
    data: XOR<OptionalSide2UncheckedUpdateInput, OptionalSide2UpdateInput>
    /**
     * Choose, which OptionalSide2 to update.
    **/
    where: OptionalSide2WhereUniqueInput
  }


  /**
   * OptionalSide2 updateMany
   */
  export type OptionalSide2UpdateManyArgs = {
    data: XOR<OptionalSide2UncheckedUpdateManyInput, OptionalSide2UpdateManyMutationInput>
    where?: OptionalSide2WhereInput
  }


  /**
   * OptionalSide2 upsert
   */
  export type OptionalSide2UpsertArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * The filter to search for the OptionalSide2 to update in case it exists.
    **/
    where: OptionalSide2WhereUniqueInput
    /**
     * In case the OptionalSide2 found by the \`where\` argument doesn't exist, create a new OptionalSide2 with this data.
    **/
    create: XOR<OptionalSide2UncheckedCreateInput, OptionalSide2CreateInput>
    /**
     * In case the OptionalSide2 was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<OptionalSide2UncheckedUpdateInput, OptionalSide2UpdateInput>
  }


  /**
   * OptionalSide2 delete
   */
  export type OptionalSide2DeleteArgs = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
    /**
     * Filter which OptionalSide2 to delete.
    **/
    where: OptionalSide2WhereUniqueInput
  }


  /**
   * OptionalSide2 deleteMany
   */
  export type OptionalSide2DeleteManyArgs = {
    where?: OptionalSide2WhereInput
  }


  /**
   * OptionalSide2 without action
   */
  export type OptionalSide2Args = {
    /**
     * Select specific fields to fetch from the OptionalSide2
    **/
    select?: OptionalSide2Select | null
    /**
     * Choose, which related nodes to fetch as well.
    **/
    include?: OptionalSide2Include | null
  }



  /**
   * Model A
   */


  export type AggregateA = {
    count: number | null
    avg: AAvgAggregateOutputType | null
    sum: ASumAggregateOutputType | null
    min: AMinAggregateOutputType | null
    max: AMaxAggregateOutputType | null
  }

  export type AAvgAggregateOutputType = {
    int: number
    sInt: number
    bInt: number
    serial: number
    sSerial: number
    bSerial: number
    inc_int: number
    inc_sInt: number
    inc_bInt: number
  }

  export type ASumAggregateOutputType = {
    int: number
    sInt: number
    bInt: BigInt
    serial: number
    sSerial: number
    bSerial: number
    inc_int: number
    inc_sInt: number
    inc_bInt: BigInt
  }

  export type AMinAggregateOutputType = {
    id: string | null
    email: string | null
    name: string | null
    int: number
    sInt: number
    bInt: BigInt
    serial: number
    sSerial: number
    bSerial: number
    inc_int: number
    inc_sInt: number
    inc_bInt: BigInt
  }

  export type AMaxAggregateOutputType = {
    id: string | null
    email: string | null
    name: string | null
    int: number
    sInt: number
    bInt: BigInt
    serial: number
    sSerial: number
    bSerial: number
    inc_int: number
    inc_sInt: number
    inc_bInt: BigInt
  }

  export type ACountAggregateOutputType = {
    id: number | null
    email: number | null
    name: number | null
    int: number
    sInt: number
    bInt: number
    serial: number
    sSerial: number
    bSerial: number
    inc_int: number
    inc_sInt: number
    inc_bInt: number
    _all: number
  }


  export type AAvgAggregateInputType = {
    int?: true
    sInt?: true
    bInt?: true
    serial?: true
    sSerial?: true
    bSerial?: true
    inc_int?: true
    inc_sInt?: true
    inc_bInt?: true
  }

  export type ASumAggregateInputType = {
    int?: true
    sInt?: true
    bInt?: true
    serial?: true
    sSerial?: true
    bSerial?: true
    inc_int?: true
    inc_sInt?: true
    inc_bInt?: true
  }

  export type AMinAggregateInputType = {
    id?: true
    email?: true
    name?: true
    int?: true
    sInt?: true
    bInt?: true
    serial?: true
    sSerial?: true
    bSerial?: true
    inc_int?: true
    inc_sInt?: true
    inc_bInt?: true
  }

  export type AMaxAggregateInputType = {
    id?: true
    email?: true
    name?: true
    int?: true
    sInt?: true
    bInt?: true
    serial?: true
    sSerial?: true
    bSerial?: true
    inc_int?: true
    inc_sInt?: true
    inc_bInt?: true
  }

  export type ACountAggregateInputType = {
    id?: true
    email?: true
    name?: true
    int?: true
    sInt?: true
    bInt?: true
    serial?: true
    sSerial?: true
    bSerial?: true
    inc_int?: true
    inc_sInt?: true
    inc_bInt?: true
    _all?: true
  }

  export type AggregateAArgs = {
    /**
     * Filter which A to aggregate.
    **/
    where?: AWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of AS to fetch.
    **/
    orderBy?: Enumerable<AOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: AWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` AS 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\` AS.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AS
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: AAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: ASumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: AMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: AMaxAggregateInputType
  }

  export type GetAAggregateType<T extends AggregateAArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetAAggregateScalarType<T[P]>
  }

  export type GetAAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof AAvgAggregateOutputType ? AAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByAArgs = {
    where?: AWhereInput
    orderBy?: Enumerable<AOrderByInput>
    by: Array<AScalarFieldEnum>
    take?: number
    skip?: number
    count?: ACountAggregateInputType
    avg?: AAvgAggregateInputType
    sum?: ASumAggregateInputType
    min?: AMinAggregateInputType
    max?: AMaxAggregateInputType
  }


  export type AGroupByOutputType = {
    id: string | null
    email: string | null
    name: string | null
    int: number | null
    sInt: number | null
    bInt: BigInt | null
    serial: number | null
    sSerial: number | null
    bSerial: number | null
    inc_int: number | null
    inc_sInt: number | null
    inc_bInt: BigInt | null
    count: ACountAggregateOutputType | null
    avg: AAvgAggregateOutputType | null
    sum: ASumAggregateOutputType | null
    min: AMinAggregateOutputType | null
    max: AMaxAggregateOutputType | null
  }

  type GetAGroupByPayload<T extends GroupByAArgs> = Promise<
    PickArray<AGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof AGroupByOutputType))]: GetScalarType<T[P], AGroupByOutputType[P]>
    }
  >
    

  export type ASelect = {
    id?: boolean
    email?: boolean
    name?: boolean
    int?: boolean
    sInt?: boolean
    bInt?: boolean
    serial?: boolean
    sSerial?: boolean
    bSerial?: boolean
    inc_int?: boolean
    inc_sInt?: boolean
    inc_bInt?: boolean
  }

  export type AGetPayload<
    S extends boolean | null | undefined | AArgs,
    U = keyof S
      > = S extends true
        ? A
    : S extends undefined
    ? never
    : S extends AArgs | FindManyAArgs
    ?'include' extends U
    ? A 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof A ?A [P]
  : 
     never
  } 
    : A
  : A


  export interface ADelegate {
    /**
     * Find zero or one A that matches the filter.
     * @param {FindUniqueAArgs} args - Arguments to find a A
     * @example
     * // Get one A
     * const a = await prisma.a.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueAArgs>(
      args: Subset<T, FindUniqueAArgs>
    ): CheckSelect<T, Prisma__AClient<A | null>, Prisma__AClient<AGetPayload<T> | null>>

    /**
     * Find the first A that matches the filter.
     * @param {FindFirstAArgs} args - Arguments to find a A
     * @example
     * // Get one A
     * const a = await prisma.a.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstAArgs>(
      args?: Subset<T, FindFirstAArgs>
    ): CheckSelect<T, Prisma__AClient<A | null>, Prisma__AClient<AGetPayload<T> | null>>

    /**
     * Find zero or more As that matches the filter.
     * @param {FindManyAArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all As
     * const as = await prisma.a.findMany()
     * 
     * // Get first 10 As
     * const as = await prisma.a.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const aWithIdOnly = await prisma.a.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyAArgs>(
      args?: Subset<T, FindManyAArgs>
    ): CheckSelect<T, Promise<Array<A>>, Promise<Array<AGetPayload<T>>>>

    /**
     * Create a A.
     * @param {ACreateArgs} args - Arguments to create a A.
     * @example
     * // Create one A
     * const A = await prisma.a.create({
     *   data: {
     *     // ... data to create a A
     *   }
     * })
     * 
    **/
    create<T extends ACreateArgs>(
      args: Subset<T, ACreateArgs>
    ): CheckSelect<T, Prisma__AClient<A>, Prisma__AClient<AGetPayload<T>>>

    /**
     * Delete a A.
     * @param {ADeleteArgs} args - Arguments to delete one A.
     * @example
     * // Delete one A
     * const A = await prisma.a.delete({
     *   where: {
     *     // ... filter to delete one A
     *   }
     * })
     * 
    **/
    delete<T extends ADeleteArgs>(
      args: Subset<T, ADeleteArgs>
    ): CheckSelect<T, Prisma__AClient<A>, Prisma__AClient<AGetPayload<T>>>

    /**
     * Update one A.
     * @param {AUpdateArgs} args - Arguments to update one A.
     * @example
     * // Update one A
     * const a = await prisma.a.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AUpdateArgs>(
      args: Subset<T, AUpdateArgs>
    ): CheckSelect<T, Prisma__AClient<A>, Prisma__AClient<AGetPayload<T>>>

    /**
     * Delete zero or more As.
     * @param {ADeleteManyArgs} args - Arguments to filter As to delete.
     * @example
     * // Delete a few As
     * const { count } = await prisma.a.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends ADeleteManyArgs>(
      args?: Subset<T, ADeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more As.
     * @param {AUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many As
     * const a = await prisma.a.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends AUpdateManyArgs>(
      args: Subset<T, AUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one A.
     * @param {AUpsertArgs} args - Arguments to update or create a A.
     * @example
     * // Update or create a A
     * const a = await prisma.a.upsert({
     *   create: {
     *     // ... data to create a A
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the A we want to update
     *   }
     * })
    **/
    upsert<T extends AUpsertArgs>(
      args: Subset<T, AUpsertArgs>
    ): CheckSelect<T, Prisma__AClient<A>, Prisma__AClient<AGetPayload<T>>>

    /**
     * Find zero or one A that matches the filter.
     * @param {FindUniqueAArgs} args - Arguments to find a A
     * @deprecated This will be deprecated please use prisma.a.findUnique
     * @example
     * // Get one A
     * const a = await prisma.a.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueAArgs>(
      args: Subset<T, FindUniqueAArgs>
    ): CheckSelect<T, Prisma__AClient<A | null>, Prisma__AClient<AGetPayload<T> | null>>

    /**
     * Count the number of As.
     * @param {FindManyAArgs} args - Arguments to filter As to count.
     * @example
     * // Count the number of As
     * const count = await prisma.a.count({
     *   where: {
     *     // ... the filter for the As we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyAArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a A.
     * @param {AggregateAArgs} 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 AggregateAArgs>(args: Subset<T, AggregateAArgs>): Promise<GetAAggregateType<T>>

    /**
     * Group by A.
     * @param {GroupByAArgs} 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 GroupByAArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByAArgs['orderBy'] }
        : { orderBy?: GroupByAArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByAArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetAGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for A.
   * 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 class Prisma__AClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';


    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * A findUnique
   */
  export type FindUniqueAArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * Filter, which A to fetch.
    **/
    where: AWhereUniqueInput
  }


  /**
   * A findFirst
   */
  export type FindFirstAArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * Filter, which A to fetch.
    **/
    where?: AWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of AS to fetch.
    **/
    orderBy?: Enumerable<AOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AS.
    **/
    cursor?: AWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` AS 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\` AS.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of AS.
    **/
    distinct?: Enumerable<AScalarFieldEnum>
  }


  /**
   * A findMany
   */
  export type FindManyAArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * Filter, which AS to fetch.
    **/
    where?: AWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of AS to fetch.
    **/
    orderBy?: Enumerable<AOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing AS.
    **/
    cursor?: AWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` AS 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\` AS.
    **/
    skip?: number
    distinct?: Enumerable<AScalarFieldEnum>
  }


  /**
   * A create
   */
  export type ACreateArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * The data needed to create a A.
    **/
    data: XOR<AUncheckedCreateInput, ACreateInput>
  }


  /**
   * A update
   */
  export type AUpdateArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * The data needed to update a A.
    **/
    data: XOR<AUncheckedUpdateInput, AUpdateInput>
    /**
     * Choose, which A to update.
    **/
    where: AWhereUniqueInput
  }


  /**
   * A updateMany
   */
  export type AUpdateManyArgs = {
    data: XOR<AUncheckedUpdateManyInput, AUpdateManyMutationInput>
    where?: AWhereInput
  }


  /**
   * A upsert
   */
  export type AUpsertArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * The filter to search for the A to update in case it exists.
    **/
    where: AWhereUniqueInput
    /**
     * In case the A found by the \`where\` argument doesn't exist, create a new A with this data.
    **/
    create: XOR<AUncheckedCreateInput, ACreateInput>
    /**
     * In case the A was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<AUncheckedUpdateInput, AUpdateInput>
  }


  /**
   * A delete
   */
  export type ADeleteArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
    /**
     * Filter which A to delete.
    **/
    where: AWhereUniqueInput
  }


  /**
   * A deleteMany
   */
  export type ADeleteManyArgs = {
    where?: AWhereInput
  }


  /**
   * A without action
   */
  export type AArgs = {
    /**
     * Select specific fields to fetch from the A
    **/
    select?: ASelect | null
  }



  /**
   * Model B
   */


  export type AggregateB = {
    count: number | null
    avg: BAvgAggregateOutputType | null
    sum: BSumAggregateOutputType | null
    min: BMinAggregateOutputType | null
    max: BMaxAggregateOutputType | null
  }

  export type BAvgAggregateOutputType = {
    float: number
    dFloat: number
    decFloat: Decimal
    numFloat: Decimal
  }

  export type BSumAggregateOutputType = {
    float: number
    dFloat: number
    decFloat: Decimal
    numFloat: Decimal
  }

  export type BMinAggregateOutputType = {
    id: string | null
    float: number
    dFloat: number
    decFloat: Decimal
    numFloat: Decimal
  }

  export type BMaxAggregateOutputType = {
    id: string | null
    float: number
    dFloat: number
    decFloat: Decimal
    numFloat: Decimal
  }

  export type BCountAggregateOutputType = {
    id: number | null
    float: number
    dFloat: number
    decFloat: number
    numFloat: number
    _all: number
  }


  export type BAvgAggregateInputType = {
    float?: true
    dFloat?: true
    decFloat?: true
    numFloat?: true
  }

  export type BSumAggregateInputType = {
    float?: true
    dFloat?: true
    decFloat?: true
    numFloat?: true
  }

  export type BMinAggregateInputType = {
    id?: true
    float?: true
    dFloat?: true
    decFloat?: true
    numFloat?: true
  }

  export type BMaxAggregateInputType = {
    id?: true
    float?: true
    dFloat?: true
    decFloat?: true
    numFloat?: true
  }

  export type BCountAggregateInputType = {
    id?: true
    float?: true
    dFloat?: true
    decFloat?: true
    numFloat?: true
    _all?: true
  }

  export type AggregateBArgs = {
    /**
     * Filter which B to aggregate.
    **/
    where?: BWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of BS to fetch.
    **/
    orderBy?: Enumerable<BOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: BWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` BS 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\` BS.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned BS
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    avg?: BAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    sum?: BSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: BMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: BMaxAggregateInputType
  }

  export type GetBAggregateType<T extends AggregateBArgs> = {
    [P in keyof T]: P extends 'count' ? number : GetBAggregateScalarType<T[P]>
  }

  export type GetBAggregateScalarType<T extends any> = {
    [P in keyof T]: P extends keyof BAvgAggregateOutputType ? BAvgAggregateOutputType[P] : never
  }

    


    
    
  export type GroupByBArgs = {
    where?: BWhereInput
    orderBy?: Enumerable<BOrderByInput>
    by: Array<BScalarFieldEnum>
    take?: number
    skip?: number
    count?: BCountAggregateInputType
    avg?: BAvgAggregateInputType
    sum?: BSumAggregateInputType
    min?: BMinAggregateInputType
    max?: BMaxAggregateInputType
  }


  export type BGroupByOutputType = {
    id: string | null
    float: number | null
    dFloat: number | null
    decFloat: Decimal | null
    numFloat: Decimal | null
    count: BCountAggregateOutputType | null
    avg: BAvgAggregateOutputType | null
    sum: BSumAggregateOutputType | null
    min: BMinAggregateOutputType | null
    max: BMaxAggregateOutputType | null
  }

  type GetBGroupByPayload<T extends GroupByBArgs> = Promise<
    PickArray<BGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof BGroupByOutputType))]: GetScalarType<T[P], BGroupByOutputType[P]>
    }
  >
    

  export type BSelect = {
    id?: boolean
    float?: boolean
    dFloat?: boolean
    decFloat?: boolean
    numFloat?: boolean
  }

  export type BGetPayload<
    S extends boolean | null | undefined | BArgs,
    U = keyof S
      > = S extends true
        ? B
    : S extends undefined
    ? never
    : S extends BArgs | FindManyBArgs
    ?'include' extends U
    ? B 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof B ?B [P]
  : 
     never
  } 
    : B
  : B


  export interface BDelegate {
    /**
     * Find zero or one B that matches the filter.
     * @param {FindUniqueBArgs} args - Arguments to find a B
     * @example
     * // Get one B
     * const b = await prisma.b.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueBArgs>(
      args: Subset<T, FindUniqueBArgs>
    ): CheckSelect<T, Prisma__BClient<B | null>, Prisma__BClient<BGetPayload<T> | null>>

    /**
     * Find the first B that matches the filter.
     * @param {FindFirstBArgs} args - Arguments to find a B
     * @example
     * // Get one B
     * const b = await prisma.b.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstBArgs>(
      args?: Subset<T, FindFirstBArgs>
    ): CheckSelect<T, Prisma__BClient<B | null>, Prisma__BClient<BGetPayload<T> | null>>

    /**
     * Find zero or more Bs that matches the filter.
     * @param {FindManyBArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Bs
     * const bs = await prisma.b.findMany()
     * 
     * // Get first 10 Bs
     * const bs = await prisma.b.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const bWithIdOnly = await prisma.b.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyBArgs>(
      args?: Subset<T, FindManyBArgs>
    ): CheckSelect<T, Promise<Array<B>>, Promise<Array<BGetPayload<T>>>>

    /**
     * Create a B.
     * @param {BCreateArgs} args - Arguments to create a B.
     * @example
     * // Create one B
     * const B = await prisma.b.create({
     *   data: {
     *     // ... data to create a B
     *   }
     * })
     * 
    **/
    create<T extends BCreateArgs>(
      args: Subset<T, BCreateArgs>
    ): CheckSelect<T, Prisma__BClient<B>, Prisma__BClient<BGetPayload<T>>>

    /**
     * Delete a B.
     * @param {BDeleteArgs} args - Arguments to delete one B.
     * @example
     * // Delete one B
     * const B = await prisma.b.delete({
     *   where: {
     *     // ... filter to delete one B
     *   }
     * })
     * 
    **/
    delete<T extends BDeleteArgs>(
      args: Subset<T, BDeleteArgs>
    ): CheckSelect<T, Prisma__BClient<B>, Prisma__BClient<BGetPayload<T>>>

    /**
     * Update one B.
     * @param {BUpdateArgs} args - Arguments to update one B.
     * @example
     * // Update one B
     * const b = await prisma.b.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends BUpdateArgs>(
      args: Subset<T, BUpdateArgs>
    ): CheckSelect<T, Prisma__BClient<B>, Prisma__BClient<BGetPayload<T>>>

    /**
     * Delete zero or more Bs.
     * @param {BDeleteManyArgs} args - Arguments to filter Bs to delete.
     * @example
     * // Delete a few Bs
     * const { count } = await prisma.b.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends BDeleteManyArgs>(
      args?: Subset<T, BDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Bs.
     * @param {BUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Bs
     * const b = await prisma.b.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends BUpdateManyArgs>(
      args: Subset<T, BUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one B.
     * @param {BUpsertArgs} args - Arguments to update or create a B.
     * @example
     * // Update or create a B
     * const b = await prisma.b.upsert({
     *   create: {
     *     // ... data to create a B
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the B we want to update
     *   }
     * })
    **/
    upsert<T extends BUpsertArgs>(
      args: Subset<T, BUpsertArgs>
    ): CheckSelect<T, Prisma__BClient<B>, Prisma__BClient<BGetPayload<T>>>

    /**
     * Find zero or one B that matches the filter.
     * @param {FindUniqueBArgs} args - Arguments to find a B
     * @deprecated This will be deprecated please use prisma.b.findUnique
     * @example
     * // Get one B
     * const b = await prisma.b.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueBArgs>(
      args: Subset<T, FindUniqueBArgs>
    ): CheckSelect<T, Prisma__BClient<B | null>, Prisma__BClient<BGetPayload<T> | null>>

    /**
     * Count the number of Bs.
     * @param {FindManyBArgs} args - Arguments to filter Bs to count.
     * @example
     * // Count the number of Bs
     * const count = await prisma.b.count({
     *   where: {
     *     // ... the filter for the Bs we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyBArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a B.
     * @param {AggregateBArgs} 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 AggregateBArgs>(args: Subset<T, AggregateBArgs>): Promise<GetBAggregateType<T>>

    /**
     * Group by B.
     * @param {GroupByBArgs} 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 GroupByBArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByBArgs['orderBy'] }
        : { orderBy?: GroupByBArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByBArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetBGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for B.
   * 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 class Prisma__BClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';


    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * B findUnique
   */
  export type FindUniqueBArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * Filter, which B to fetch.
    **/
    where: BWhereUniqueInput
  }


  /**
   * B findFirst
   */
  export type FindFirstBArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * Filter, which B to fetch.
    **/
    where?: BWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of BS to fetch.
    **/
    orderBy?: Enumerable<BOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BS.
    **/
    cursor?: BWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` BS 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\` BS.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of BS.
    **/
    distinct?: Enumerable<BScalarFieldEnum>
  }


  /**
   * B findMany
   */
  export type FindManyBArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * Filter, which BS to fetch.
    **/
    where?: BWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of BS to fetch.
    **/
    orderBy?: Enumerable<BOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing BS.
    **/
    cursor?: BWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` BS 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\` BS.
    **/
    skip?: number
    distinct?: Enumerable<BScalarFieldEnum>
  }


  /**
   * B create
   */
  export type BCreateArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * The data needed to create a B.
    **/
    data: XOR<BUncheckedCreateInput, BCreateInput>
  }


  /**
   * B update
   */
  export type BUpdateArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * The data needed to update a B.
    **/
    data: XOR<BUncheckedUpdateInput, BUpdateInput>
    /**
     * Choose, which B to update.
    **/
    where: BWhereUniqueInput
  }


  /**
   * B updateMany
   */
  export type BUpdateManyArgs = {
    data: XOR<BUncheckedUpdateManyInput, BUpdateManyMutationInput>
    where?: BWhereInput
  }


  /**
   * B upsert
   */
  export type BUpsertArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * The filter to search for the B to update in case it exists.
    **/
    where: BWhereUniqueInput
    /**
     * In case the B found by the \`where\` argument doesn't exist, create a new B with this data.
    **/
    create: XOR<BUncheckedCreateInput, BCreateInput>
    /**
     * In case the B was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<BUncheckedUpdateInput, BUpdateInput>
  }


  /**
   * B delete
   */
  export type BDeleteArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
    /**
     * Filter which B to delete.
    **/
    where: BWhereUniqueInput
  }


  /**
   * B deleteMany
   */
  export type BDeleteManyArgs = {
    where?: BWhereInput
  }


  /**
   * B without action
   */
  export type BArgs = {
    /**
     * Select specific fields to fetch from the B
    **/
    select?: BSelect | null
  }



  /**
   * Model C
   */


  export type AggregateC = {
    count: number | null
    min: CMinAggregateOutputType | null
    max: CMaxAggregateOutputType | null
  }

  export type CMinAggregateOutputType = {
    id: string | null
    char: string | null
    vChar: string | null
    text: string | null
    bit: string | null
    vBit: string | null
    uuid: string | null
  }

  export type CMaxAggregateOutputType = {
    id: string | null
    char: string | null
    vChar: string | null
    text: string | null
    bit: string | null
    vBit: string | null
    uuid: string | null
  }

  export type CCountAggregateOutputType = {
    id: number | null
    char: number | null
    vChar: number | null
    text: number | null
    bit: number | null
    vBit: number | null
    uuid: number | null
    _all: number
  }


  export type CMinAggregateInputType = {
    id?: true
    char?: true
    vChar?: true
    text?: true
    bit?: true
    vBit?: true
    uuid?: true
  }

  export type CMaxAggregateInputType = {
    id?: true
    char?: true
    vChar?: true
    text?: true
    bit?: true
    vBit?: true
    uuid?: true
  }

  export type CCountAggregateInputType = {
    id?: true
    char?: true
    vChar?: true
    text?: true
    bit?: true
    vBit?: true
    uuid?: true
    _all?: true
  }

  export type AggregateCArgs = {
    /**
     * Filter which C to aggregate.
    **/
    where?: CWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of CS to fetch.
    **/
    orderBy?: Enumerable<COrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: CWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` CS 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\` CS.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CS
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: CMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: CMaxAggregateInputType
  }

  export type GetCAggregateType<T extends AggregateCArgs> = {
    [P in keyof T]: P extends 'count' ? number : never
  }



    


    
    
  export type GroupByCArgs = {
    where?: CWhereInput
    orderBy?: Enumerable<COrderByInput>
    by: Array<CScalarFieldEnum>
    take?: number
    skip?: number
    count?: CCountAggregateInputType
    min?: CMinAggregateInputType
    max?: CMaxAggregateInputType
  }


  export type CGroupByOutputType = {
    id: string | null
    char: string | null
    vChar: string | null
    text: string | null
    bit: string | null
    vBit: string | null
    uuid: string | null
    count: CCountAggregateOutputType | null
    min: CMinAggregateOutputType | null
    max: CMaxAggregateOutputType | null
  }

  type GetCGroupByPayload<T extends GroupByCArgs> = Promise<
    PickArray<CGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof CGroupByOutputType))]: GetScalarType<T[P], CGroupByOutputType[P]>
    }
  >
    

  export type CSelect = {
    id?: boolean
    char?: boolean
    vChar?: boolean
    text?: boolean
    bit?: boolean
    vBit?: boolean
    uuid?: boolean
  }

  export type CGetPayload<
    S extends boolean | null | undefined | CArgs,
    U = keyof S
      > = S extends true
        ? C
    : S extends undefined
    ? never
    : S extends CArgs | FindManyCArgs
    ?'include' extends U
    ? C 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof C ?C [P]
  : 
     never
  } 
    : C
  : C


  export interface CDelegate {
    /**
     * Find zero or one C that matches the filter.
     * @param {FindUniqueCArgs} args - Arguments to find a C
     * @example
     * // Get one C
     * const c = await prisma.c.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueCArgs>(
      args: Subset<T, FindUniqueCArgs>
    ): CheckSelect<T, Prisma__CClient<C | null>, Prisma__CClient<CGetPayload<T> | null>>

    /**
     * Find the first C that matches the filter.
     * @param {FindFirstCArgs} args - Arguments to find a C
     * @example
     * // Get one C
     * const c = await prisma.c.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstCArgs>(
      args?: Subset<T, FindFirstCArgs>
    ): CheckSelect<T, Prisma__CClient<C | null>, Prisma__CClient<CGetPayload<T> | null>>

    /**
     * Find zero or more Cs that matches the filter.
     * @param {FindManyCArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Cs
     * const cs = await prisma.c.findMany()
     * 
     * // Get first 10 Cs
     * const cs = await prisma.c.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const cWithIdOnly = await prisma.c.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyCArgs>(
      args?: Subset<T, FindManyCArgs>
    ): CheckSelect<T, Promise<Array<C>>, Promise<Array<CGetPayload<T>>>>

    /**
     * Create a C.
     * @param {CCreateArgs} args - Arguments to create a C.
     * @example
     * // Create one C
     * const C = await prisma.c.create({
     *   data: {
     *     // ... data to create a C
     *   }
     * })
     * 
    **/
    create<T extends CCreateArgs>(
      args: Subset<T, CCreateArgs>
    ): CheckSelect<T, Prisma__CClient<C>, Prisma__CClient<CGetPayload<T>>>

    /**
     * Delete a C.
     * @param {CDeleteArgs} args - Arguments to delete one C.
     * @example
     * // Delete one C
     * const C = await prisma.c.delete({
     *   where: {
     *     // ... filter to delete one C
     *   }
     * })
     * 
    **/
    delete<T extends CDeleteArgs>(
      args: Subset<T, CDeleteArgs>
    ): CheckSelect<T, Prisma__CClient<C>, Prisma__CClient<CGetPayload<T>>>

    /**
     * Update one C.
     * @param {CUpdateArgs} args - Arguments to update one C.
     * @example
     * // Update one C
     * const c = await prisma.c.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CUpdateArgs>(
      args: Subset<T, CUpdateArgs>
    ): CheckSelect<T, Prisma__CClient<C>, Prisma__CClient<CGetPayload<T>>>

    /**
     * Delete zero or more Cs.
     * @param {CDeleteManyArgs} args - Arguments to filter Cs to delete.
     * @example
     * // Delete a few Cs
     * const { count } = await prisma.c.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends CDeleteManyArgs>(
      args?: Subset<T, CDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Cs.
     * @param {CUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Cs
     * const c = await prisma.c.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends CUpdateManyArgs>(
      args: Subset<T, CUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one C.
     * @param {CUpsertArgs} args - Arguments to update or create a C.
     * @example
     * // Update or create a C
     * const c = await prisma.c.upsert({
     *   create: {
     *     // ... data to create a C
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the C we want to update
     *   }
     * })
    **/
    upsert<T extends CUpsertArgs>(
      args: Subset<T, CUpsertArgs>
    ): CheckSelect<T, Prisma__CClient<C>, Prisma__CClient<CGetPayload<T>>>

    /**
     * Find zero or one C that matches the filter.
     * @param {FindUniqueCArgs} args - Arguments to find a C
     * @deprecated This will be deprecated please use prisma.c.findUnique
     * @example
     * // Get one C
     * const c = await prisma.c.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueCArgs>(
      args: Subset<T, FindUniqueCArgs>
    ): CheckSelect<T, Prisma__CClient<C | null>, Prisma__CClient<CGetPayload<T> | null>>

    /**
     * Count the number of Cs.
     * @param {FindManyCArgs} args - Arguments to filter Cs to count.
     * @example
     * // Count the number of Cs
     * const count = await prisma.c.count({
     *   where: {
     *     // ... the filter for the Cs we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyCArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a C.
     * @param {AggregateCArgs} 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 AggregateCArgs>(args: Subset<T, AggregateCArgs>): Promise<GetCAggregateType<T>>

    /**
     * Group by C.
     * @param {GroupByCArgs} 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 GroupByCArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByCArgs['orderBy'] }
        : { orderBy?: GroupByCArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByCArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetCGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for C.
   * 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 class Prisma__CClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';


    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * C findUnique
   */
  export type FindUniqueCArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * Filter, which C to fetch.
    **/
    where: CWhereUniqueInput
  }


  /**
   * C findFirst
   */
  export type FindFirstCArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * Filter, which C to fetch.
    **/
    where?: CWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of CS to fetch.
    **/
    orderBy?: Enumerable<COrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CS.
    **/
    cursor?: CWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` CS 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\` CS.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of CS.
    **/
    distinct?: Enumerable<CScalarFieldEnum>
  }


  /**
   * C findMany
   */
  export type FindManyCArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * Filter, which CS to fetch.
    **/
    where?: CWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of CS to fetch.
    **/
    orderBy?: Enumerable<COrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CS.
    **/
    cursor?: CWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` CS 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\` CS.
    **/
    skip?: number
    distinct?: Enumerable<CScalarFieldEnum>
  }


  /**
   * C create
   */
  export type CCreateArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * The data needed to create a C.
    **/
    data: XOR<CUncheckedCreateInput, CCreateInput>
  }


  /**
   * C update
   */
  export type CUpdateArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * The data needed to update a C.
    **/
    data: XOR<CUncheckedUpdateInput, CUpdateInput>
    /**
     * Choose, which C to update.
    **/
    where: CWhereUniqueInput
  }


  /**
   * C updateMany
   */
  export type CUpdateManyArgs = {
    data: XOR<CUncheckedUpdateManyInput, CUpdateManyMutationInput>
    where?: CWhereInput
  }


  /**
   * C upsert
   */
  export type CUpsertArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * The filter to search for the C to update in case it exists.
    **/
    where: CWhereUniqueInput
    /**
     * In case the C found by the \`where\` argument doesn't exist, create a new C with this data.
    **/
    create: XOR<CUncheckedCreateInput, CCreateInput>
    /**
     * In case the C was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<CUncheckedUpdateInput, CUpdateInput>
  }


  /**
   * C delete
   */
  export type CDeleteArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
    /**
     * Filter which C to delete.
    **/
    where: CWhereUniqueInput
  }


  /**
   * C deleteMany
   */
  export type CDeleteManyArgs = {
    where?: CWhereInput
  }


  /**
   * C without action
   */
  export type CArgs = {
    /**
     * Select specific fields to fetch from the C
    **/
    select?: CSelect | null
  }



  /**
   * Model D
   */


  export type AggregateD = {
    count: number | null
    min: DMinAggregateOutputType | null
    max: DMaxAggregateOutputType | null
  }

  export type DMinAggregateOutputType = {
    id: string | null
    bool: boolean | null
    byteA: Buffer | null
    xml: string | null
    json: JsonValue | null
    jsonb: JsonValue | null
  }

  export type DMaxAggregateOutputType = {
    id: string | null
    bool: boolean | null
    byteA: Buffer | null
    xml: string | null
    json: JsonValue | null
    jsonb: JsonValue | null
  }

  export type DCountAggregateOutputType = {
    id: number | null
    bool: number | null
    byteA: number | null
    xml: number | null
    json: number | null
    jsonb: number | null
    _all: number
  }


  export type DMinAggregateInputType = {
    id?: true
    bool?: true
    byteA?: true
    xml?: true
    json?: true
    jsonb?: true
  }

  export type DMaxAggregateInputType = {
    id?: true
    bool?: true
    byteA?: true
    xml?: true
    json?: true
    jsonb?: true
  }

  export type DCountAggregateInputType = {
    id?: true
    bool?: true
    byteA?: true
    xml?: true
    json?: true
    jsonb?: true
    _all?: true
  }

  export type AggregateDArgs = {
    /**
     * Filter which D to aggregate.
    **/
    where?: DWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of DS to fetch.
    **/
    orderBy?: Enumerable<DOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: DWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` DS 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\` DS.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned DS
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: DMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: DMaxAggregateInputType
  }

  export type GetDAggregateType<T extends AggregateDArgs> = {
    [P in keyof T]: P extends 'count' ? number : never
  }



    


    
    
  export type GroupByDArgs = {
    where?: DWhereInput
    orderBy?: Enumerable<DOrderByInput>
    by: Array<DScalarFieldEnum>
    take?: number
    skip?: number
    count?: DCountAggregateInputType
    min?: DMinAggregateInputType
    max?: DMaxAggregateInputType
  }


  export type DGroupByOutputType = {
    id: string | null
    bool: boolean | null
    byteA: Buffer | null
    xml: string | null
    json: JsonValue | null
    jsonb: JsonValue | null
    count: DCountAggregateOutputType | null
    min: DMinAggregateOutputType | null
    max: DMaxAggregateOutputType | null
  }

  type GetDGroupByPayload<T extends GroupByDArgs> = Promise<
    PickArray<DGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof DGroupByOutputType))]: GetScalarType<T[P], DGroupByOutputType[P]>
    }
  >
    

  export type DSelect = {
    id?: boolean
    bool?: boolean
    byteA?: boolean
    xml?: boolean
    json?: boolean
    jsonb?: boolean
  }

  export type DGetPayload<
    S extends boolean | null | undefined | DArgs,
    U = keyof S
      > = S extends true
        ? D
    : S extends undefined
    ? never
    : S extends DArgs | FindManyDArgs
    ?'include' extends U
    ? D 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof D ?D [P]
  : 
     never
  } 
    : D
  : D


  export interface DDelegate {
    /**
     * Find zero or one D that matches the filter.
     * @param {FindUniqueDArgs} args - Arguments to find a D
     * @example
     * // Get one D
     * const d = await prisma.d.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueDArgs>(
      args: Subset<T, FindUniqueDArgs>
    ): CheckSelect<T, Prisma__DClient<D | null>, Prisma__DClient<DGetPayload<T> | null>>

    /**
     * Find the first D that matches the filter.
     * @param {FindFirstDArgs} args - Arguments to find a D
     * @example
     * // Get one D
     * const d = await prisma.d.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstDArgs>(
      args?: Subset<T, FindFirstDArgs>
    ): CheckSelect<T, Prisma__DClient<D | null>, Prisma__DClient<DGetPayload<T> | null>>

    /**
     * Find zero or more Ds that matches the filter.
     * @param {FindManyDArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Ds
     * const ds = await prisma.d.findMany()
     * 
     * // Get first 10 Ds
     * const ds = await prisma.d.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const dWithIdOnly = await prisma.d.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyDArgs>(
      args?: Subset<T, FindManyDArgs>
    ): CheckSelect<T, Promise<Array<D>>, Promise<Array<DGetPayload<T>>>>

    /**
     * Create a D.
     * @param {DCreateArgs} args - Arguments to create a D.
     * @example
     * // Create one D
     * const D = await prisma.d.create({
     *   data: {
     *     // ... data to create a D
     *   }
     * })
     * 
    **/
    create<T extends DCreateArgs>(
      args: Subset<T, DCreateArgs>
    ): CheckSelect<T, Prisma__DClient<D>, Prisma__DClient<DGetPayload<T>>>

    /**
     * Delete a D.
     * @param {DDeleteArgs} args - Arguments to delete one D.
     * @example
     * // Delete one D
     * const D = await prisma.d.delete({
     *   where: {
     *     // ... filter to delete one D
     *   }
     * })
     * 
    **/
    delete<T extends DDeleteArgs>(
      args: Subset<T, DDeleteArgs>
    ): CheckSelect<T, Prisma__DClient<D>, Prisma__DClient<DGetPayload<T>>>

    /**
     * Update one D.
     * @param {DUpdateArgs} args - Arguments to update one D.
     * @example
     * // Update one D
     * const d = await prisma.d.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends DUpdateArgs>(
      args: Subset<T, DUpdateArgs>
    ): CheckSelect<T, Prisma__DClient<D>, Prisma__DClient<DGetPayload<T>>>

    /**
     * Delete zero or more Ds.
     * @param {DDeleteManyArgs} args - Arguments to filter Ds to delete.
     * @example
     * // Delete a few Ds
     * const { count } = await prisma.d.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends DDeleteManyArgs>(
      args?: Subset<T, DDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Ds.
     * @param {DUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Ds
     * const d = await prisma.d.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends DUpdateManyArgs>(
      args: Subset<T, DUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one D.
     * @param {DUpsertArgs} args - Arguments to update or create a D.
     * @example
     * // Update or create a D
     * const d = await prisma.d.upsert({
     *   create: {
     *     // ... data to create a D
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the D we want to update
     *   }
     * })
    **/
    upsert<T extends DUpsertArgs>(
      args: Subset<T, DUpsertArgs>
    ): CheckSelect<T, Prisma__DClient<D>, Prisma__DClient<DGetPayload<T>>>

    /**
     * Find zero or one D that matches the filter.
     * @param {FindUniqueDArgs} args - Arguments to find a D
     * @deprecated This will be deprecated please use prisma.d.findUnique
     * @example
     * // Get one D
     * const d = await prisma.d.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueDArgs>(
      args: Subset<T, FindUniqueDArgs>
    ): CheckSelect<T, Prisma__DClient<D | null>, Prisma__DClient<DGetPayload<T> | null>>

    /**
     * Count the number of Ds.
     * @param {FindManyDArgs} args - Arguments to filter Ds to count.
     * @example
     * // Count the number of Ds
     * const count = await prisma.d.count({
     *   where: {
     *     // ... the filter for the Ds we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyDArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a D.
     * @param {AggregateDArgs} 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 AggregateDArgs>(args: Subset<T, AggregateDArgs>): Promise<GetDAggregateType<T>>

    /**
     * Group by D.
     * @param {GroupByDArgs} 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 GroupByDArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByDArgs['orderBy'] }
        : { orderBy?: GroupByDArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByDArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetDGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for D.
   * 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 class Prisma__DClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';


    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * D findUnique
   */
  export type FindUniqueDArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * Filter, which D to fetch.
    **/
    where: DWhereUniqueInput
  }


  /**
   * D findFirst
   */
  export type FindFirstDArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * Filter, which D to fetch.
    **/
    where?: DWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of DS to fetch.
    **/
    orderBy?: Enumerable<DOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for DS.
    **/
    cursor?: DWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` DS 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\` DS.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of DS.
    **/
    distinct?: Enumerable<DScalarFieldEnum>
  }


  /**
   * D findMany
   */
  export type FindManyDArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * Filter, which DS to fetch.
    **/
    where?: DWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of DS to fetch.
    **/
    orderBy?: Enumerable<DOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing DS.
    **/
    cursor?: DWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` DS 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\` DS.
    **/
    skip?: number
    distinct?: Enumerable<DScalarFieldEnum>
  }


  /**
   * D create
   */
  export type DCreateArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * The data needed to create a D.
    **/
    data: XOR<DUncheckedCreateInput, DCreateInput>
  }


  /**
   * D update
   */
  export type DUpdateArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * The data needed to update a D.
    **/
    data: XOR<DUncheckedUpdateInput, DUpdateInput>
    /**
     * Choose, which D to update.
    **/
    where: DWhereUniqueInput
  }


  /**
   * D updateMany
   */
  export type DUpdateManyArgs = {
    data: XOR<DUncheckedUpdateManyInput, DUpdateManyMutationInput>
    where?: DWhereInput
  }


  /**
   * D upsert
   */
  export type DUpsertArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * The filter to search for the D to update in case it exists.
    **/
    where: DWhereUniqueInput
    /**
     * In case the D found by the \`where\` argument doesn't exist, create a new D with this data.
    **/
    create: XOR<DUncheckedCreateInput, DCreateInput>
    /**
     * In case the D was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<DUncheckedUpdateInput, DUpdateInput>
  }


  /**
   * D delete
   */
  export type DDeleteArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
    /**
     * Filter which D to delete.
    **/
    where: DWhereUniqueInput
  }


  /**
   * D deleteMany
   */
  export type DDeleteManyArgs = {
    where?: DWhereInput
  }


  /**
   * D without action
   */
  export type DArgs = {
    /**
     * Select specific fields to fetch from the D
    **/
    select?: DSelect | null
  }



  /**
   * Model E
   */


  export type AggregateE = {
    count: number | null
    min: EMinAggregateOutputType | null
    max: EMaxAggregateOutputType | null
  }

  export type EMinAggregateOutputType = {
    id: string | null
    date: Date | null
    time: Date | null
    ts: Date | null
  }

  export type EMaxAggregateOutputType = {
    id: string | null
    date: Date | null
    time: Date | null
    ts: Date | null
  }

  export type ECountAggregateOutputType = {
    id: number | null
    date: number | null
    time: number | null
    ts: number | null
    _all: number
  }


  export type EMinAggregateInputType = {
    id?: true
    date?: true
    time?: true
    ts?: true
  }

  export type EMaxAggregateInputType = {
    id?: true
    date?: true
    time?: true
    ts?: true
  }

  export type ECountAggregateInputType = {
    id?: true
    date?: true
    time?: true
    ts?: true
    _all?: true
  }

  export type AggregateEArgs = {
    /**
     * Filter which E to aggregate.
    **/
    where?: EWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of ES to fetch.
    **/
    orderBy?: Enumerable<EOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
    **/
    cursor?: EWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` ES 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\` ES.
    **/
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ES
    **/
    count?: true
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    min?: EMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    max?: EMaxAggregateInputType
  }

  export type GetEAggregateType<T extends AggregateEArgs> = {
    [P in keyof T]: P extends 'count' ? number : never
  }



    


    
    
  export type GroupByEArgs = {
    where?: EWhereInput
    orderBy?: Enumerable<EOrderByInput>
    by: Array<EScalarFieldEnum>
    take?: number
    skip?: number
    count?: ECountAggregateInputType
    min?: EMinAggregateInputType
    max?: EMaxAggregateInputType
  }


  export type EGroupByOutputType = {
    id: string | null
    date: Date | null
    time: Date | null
    ts: Date | null
    count: ECountAggregateOutputType | null
    min: EMinAggregateOutputType | null
    max: EMaxAggregateOutputType | null
  }

  type GetEGroupByPayload<T extends GroupByEArgs> = Promise<
    PickArray<EGroupByOutputType, T['by']> & {
      [P in ((keyof T) & (keyof EGroupByOutputType))]: GetScalarType<T[P], EGroupByOutputType[P]>
    }
  >
    

  export type ESelect = {
    id?: boolean
    date?: boolean
    time?: boolean
    ts?: boolean
  }

  export type EGetPayload<
    S extends boolean | null | undefined | EArgs,
    U = keyof S
      > = S extends true
        ? E
    : S extends undefined
    ? never
    : S extends EArgs | FindManyEArgs
    ?'include' extends U
    ? E 
    : 'select' extends U
    ? {
    [P in TrueKeys<S['select']>]: P extends keyof E ?E [P]
  : 
     never
  } 
    : E
  : E


  export interface EDelegate {
    /**
     * Find zero or one E that matches the filter.
     * @param {FindUniqueEArgs} args - Arguments to find a E
     * @example
     * // Get one E
     * const e = await prisma.e.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FindUniqueEArgs>(
      args: Subset<T, FindUniqueEArgs>
    ): CheckSelect<T, Prisma__EClient<E | null>, Prisma__EClient<EGetPayload<T> | null>>

    /**
     * Find the first E that matches the filter.
     * @param {FindFirstEArgs} args - Arguments to find a E
     * @example
     * // Get one E
     * const e = await prisma.e.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FindFirstEArgs>(
      args?: Subset<T, FindFirstEArgs>
    ): CheckSelect<T, Prisma__EClient<E | null>, Prisma__EClient<EGetPayload<T> | null>>

    /**
     * Find zero or more Es that matches the filter.
     * @param {FindManyEArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Es
     * const es = await prisma.e.findMany()
     * 
     * // Get first 10 Es
     * const es = await prisma.e.findMany({ take: 10 })
     * 
     * // Only select the \`id\`
     * const eWithIdOnly = await prisma.e.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FindManyEArgs>(
      args?: Subset<T, FindManyEArgs>
    ): CheckSelect<T, Promise<Array<E>>, Promise<Array<EGetPayload<T>>>>

    /**
     * Create a E.
     * @param {ECreateArgs} args - Arguments to create a E.
     * @example
     * // Create one E
     * const E = await prisma.e.create({
     *   data: {
     *     // ... data to create a E
     *   }
     * })
     * 
    **/
    create<T extends ECreateArgs>(
      args: Subset<T, ECreateArgs>
    ): CheckSelect<T, Prisma__EClient<E>, Prisma__EClient<EGetPayload<T>>>

    /**
     * Delete a E.
     * @param {EDeleteArgs} args - Arguments to delete one E.
     * @example
     * // Delete one E
     * const E = await prisma.e.delete({
     *   where: {
     *     // ... filter to delete one E
     *   }
     * })
     * 
    **/
    delete<T extends EDeleteArgs>(
      args: Subset<T, EDeleteArgs>
    ): CheckSelect<T, Prisma__EClient<E>, Prisma__EClient<EGetPayload<T>>>

    /**
     * Update one E.
     * @param {EUpdateArgs} args - Arguments to update one E.
     * @example
     * // Update one E
     * const e = await prisma.e.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends EUpdateArgs>(
      args: Subset<T, EUpdateArgs>
    ): CheckSelect<T, Prisma__EClient<E>, Prisma__EClient<EGetPayload<T>>>

    /**
     * Delete zero or more Es.
     * @param {EDeleteManyArgs} args - Arguments to filter Es to delete.
     * @example
     * // Delete a few Es
     * const { count } = await prisma.e.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends EDeleteManyArgs>(
      args?: Subset<T, EDeleteManyArgs>
    ): Promise<BatchPayload>

    /**
     * Update zero or more Es.
     * @param {EUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Es
     * const e = await prisma.e.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends EUpdateManyArgs>(
      args: Subset<T, EUpdateManyArgs>
    ): Promise<BatchPayload>

    /**
     * Create or update one E.
     * @param {EUpsertArgs} args - Arguments to update or create a E.
     * @example
     * // Update or create a E
     * const e = await prisma.e.upsert({
     *   create: {
     *     // ... data to create a E
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the E we want to update
     *   }
     * })
    **/
    upsert<T extends EUpsertArgs>(
      args: Subset<T, EUpsertArgs>
    ): CheckSelect<T, Prisma__EClient<E>, Prisma__EClient<EGetPayload<T>>>

    /**
     * Find zero or one E that matches the filter.
     * @param {FindUniqueEArgs} args - Arguments to find a E
     * @deprecated This will be deprecated please use prisma.e.findUnique
     * @example
     * // Get one E
     * const e = await prisma.e.findOne({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findOne<T extends FindUniqueEArgs>(
      args: Subset<T, FindUniqueEArgs>
    ): CheckSelect<T, Prisma__EClient<E | null>, Prisma__EClient<EGetPayload<T> | null>>

    /**
     * Count the number of Es.
     * @param {FindManyEArgs} args - Arguments to filter Es to count.
     * @example
     * // Count the number of Es
     * const count = await prisma.e.count({
     *   where: {
     *     // ... the filter for the Es we want to count
     *   }
     * })
    **/
    count(args?: Omit<FindManyEArgs, 'select' | 'include'>): Promise<number>

    /**
     * Allows you to perform aggregations operations on a E.
     * @param {AggregateEArgs} 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 AggregateEArgs>(args: Subset<T, AggregateEArgs>): Promise<GetEAggregateType<T>>

    /**
     * Group by E.
     * @param {GroupByEArgs} 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 GroupByEArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupByEArgs['orderBy'] }
        : { orderBy?: GroupByEArgs['orderBy'] },
      OrderFields extends Keys<MaybeTupleToUnion<T['orderBy']>>,
      ByFields extends TupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      InputErrors extends '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, GroupByEArgs, OrderByArg> & InputErrors): {} extends InputErrors ? Promise<GetEGroupByPayload<T>> : Promise<InputErrors>
  }

  /**
   * The delegate class that acts as a "Promise-like" for E.
   * 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 class Prisma__EClient<T> implements Promise<T> {
    private readonly _dmmf;
    private readonly _fetcher;
    private readonly _queryType;
    private readonly _rootField;
    private readonly _clientMethod;
    private readonly _args;
    private readonly _dataPath;
    private readonly _errorFormat;
    private readonly _measurePerformance?;
    private _isList;
    private _callsite;
    private _requestPromise?;
    constructor(_dmmf: runtime.DMMFClass, _fetcher: PrismaClientFetcher, _queryType: 'query' | 'mutation', _rootField: string, _clientMethod: string, _args: any, _dataPath: string[], _errorFormat: ErrorFormat, _measurePerformance?: boolean | undefined, _isList?: boolean);
    readonly [Symbol.toStringTag]: 'PrismaClientPromise';


    private get _document();
    /**
     * 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 | Promise<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null): Promise<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 | Promise<TResult>) | undefined | null): Promise<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): Promise<T>;
  }

  // Custom InputTypes

  /**
   * E findUnique
   */
  export type FindUniqueEArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * Filter, which E to fetch.
    **/
    where: EWhereUniqueInput
  }


  /**
   * E findFirst
   */
  export type FindFirstEArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * Filter, which E to fetch.
    **/
    where?: EWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of ES to fetch.
    **/
    orderBy?: Enumerable<EOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ES.
    **/
    cursor?: EWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` ES 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\` ES.
    **/
    skip?: number
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs
     * 
     * Filter by unique combinations of ES.
    **/
    distinct?: Enumerable<EScalarFieldEnum>
  }


  /**
   * E findMany
   */
  export type FindManyEArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * Filter, which ES to fetch.
    **/
    where?: EWhereInput
    /**
     * @link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs
     * 
     * Determine the order of ES to fetch.
    **/
    orderBy?: Enumerable<EOrderByInput>
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ES.
    **/
    cursor?: EWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take \`±n\` ES 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\` ES.
    **/
    skip?: number
    distinct?: Enumerable<EScalarFieldEnum>
  }


  /**
   * E create
   */
  export type ECreateArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * The data needed to create a E.
    **/
    data: XOR<EUncheckedCreateInput, ECreateInput>
  }


  /**
   * E update
   */
  export type EUpdateArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * The data needed to update a E.
    **/
    data: XOR<EUncheckedUpdateInput, EUpdateInput>
    /**
     * Choose, which E to update.
    **/
    where: EWhereUniqueInput
  }


  /**
   * E updateMany
   */
  export type EUpdateManyArgs = {
    data: XOR<EUncheckedUpdateManyInput, EUpdateManyMutationInput>
    where?: EWhereInput
  }


  /**
   * E upsert
   */
  export type EUpsertArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * The filter to search for the E to update in case it exists.
    **/
    where: EWhereUniqueInput
    /**
     * In case the E found by the \`where\` argument doesn't exist, create a new E with this data.
    **/
    create: XOR<EUncheckedCreateInput, ECreateInput>
    /**
     * In case the E was found with the provided \`where\` argument, update it with this data.
    **/
    update: XOR<EUncheckedUpdateInput, EUpdateInput>
  }


  /**
   * E delete
   */
  export type EDeleteArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
    /**
     * Filter which E to delete.
    **/
    where: EWhereUniqueInput
  }


  /**
   * E deleteMany
   */
  export type EDeleteManyArgs = {
    where?: EWhereInput
  }


  /**
   * E without action
   */
  export type EArgs = {
    /**
     * Select specific fields to fetch from the E
    **/
    select?: ESelect | null
  }



  /**
   * Enums
   */

  // Based on
  // https://github.com/microsoft/TypeScript/issues/3192#issuecomment-261720275

  export const PostScalarFieldEnum: {
    id: 'id',
    createdAt: 'createdAt',
    title: 'title',
    content: 'content',
    published: 'published',
    authorId: 'authorId'
  };

  export type PostScalarFieldEnum = (typeof PostScalarFieldEnum)[keyof typeof PostScalarFieldEnum]


  export const UserScalarFieldEnum: {
    id: 'id',
    email: 'email',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]


  export const MScalarFieldEnum: {
    id: 'id',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type MScalarFieldEnum = (typeof MScalarFieldEnum)[keyof typeof MScalarFieldEnum]


  export const NScalarFieldEnum: {
    id: 'id',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type NScalarFieldEnum = (typeof NScalarFieldEnum)[keyof typeof NScalarFieldEnum]


  export const OneOptionalScalarFieldEnum: {
    id: 'id',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type OneOptionalScalarFieldEnum = (typeof OneOptionalScalarFieldEnum)[keyof typeof OneOptionalScalarFieldEnum]


  export const ManyRequiredScalarFieldEnum: {
    id: 'id',
    oneOptionalId: 'oneOptionalId',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type ManyRequiredScalarFieldEnum = (typeof ManyRequiredScalarFieldEnum)[keyof typeof ManyRequiredScalarFieldEnum]


  export const OptionalSide1ScalarFieldEnum: {
    id: 'id',
    optionalSide2Id: 'optionalSide2Id',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type OptionalSide1ScalarFieldEnum = (typeof OptionalSide1ScalarFieldEnum)[keyof typeof OptionalSide1ScalarFieldEnum]


  export const OptionalSide2ScalarFieldEnum: {
    id: 'id',
    int: 'int',
    optionalInt: 'optionalInt',
    float: 'float',
    optionalFloat: 'optionalFloat',
    string: 'string',
    optionalString: 'optionalString',
    json: 'json',
    optionalJson: 'optionalJson',
    enum: 'enum',
    optionalEnum: 'optionalEnum',
    boolean: 'boolean',
    optionalBoolean: 'optionalBoolean'
  };

  export type OptionalSide2ScalarFieldEnum = (typeof OptionalSide2ScalarFieldEnum)[keyof typeof OptionalSide2ScalarFieldEnum]


  export const AScalarFieldEnum: {
    id: 'id',
    email: 'email',
    name: 'name',
    int: 'int',
    sInt: 'sInt',
    bInt: 'bInt',
    serial: 'serial',
    sSerial: 'sSerial',
    bSerial: 'bSerial',
    inc_int: 'inc_int',
    inc_sInt: 'inc_sInt',
    inc_bInt: 'inc_bInt'
  };

  export type AScalarFieldEnum = (typeof AScalarFieldEnum)[keyof typeof AScalarFieldEnum]


  export const BScalarFieldEnum: {
    id: 'id',
    float: 'float',
    dFloat: 'dFloat',
    decFloat: 'decFloat',
    numFloat: 'numFloat'
  };

  export type BScalarFieldEnum = (typeof BScalarFieldEnum)[keyof typeof BScalarFieldEnum]


  export const CScalarFieldEnum: {
    id: 'id',
    char: 'char',
    vChar: 'vChar',
    text: 'text',
    bit: 'bit',
    vBit: 'vBit',
    uuid: 'uuid'
  };

  export type CScalarFieldEnum = (typeof CScalarFieldEnum)[keyof typeof CScalarFieldEnum]


  export const DScalarFieldEnum: {
    id: 'id',
    bool: 'bool',
    byteA: 'byteA',
    xml: 'xml',
    json: 'json',
    jsonb: 'jsonb'
  };

  export type DScalarFieldEnum = (typeof DScalarFieldEnum)[keyof typeof DScalarFieldEnum]


  export const EScalarFieldEnum: {
    id: 'id',
    date: 'date',
    time: 'time',
    ts: 'ts'
  };

  export type EScalarFieldEnum = (typeof EScalarFieldEnum)[keyof typeof EScalarFieldEnum]


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

  export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

  export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]


  /**
   * Deep Input Types
   */


  export type PostWhereInput = {
    AND?: Enumerable<PostWhereInput>
    OR?: Enumerable<PostWhereInput>
    NOT?: Enumerable<PostWhereInput>
    id?: IntFilter | number
    createdAt?: DateTimeFilter | Date | string
    title?: StringFilter | string
    content?: StringNullableFilter | string | null
    published?: BoolFilter | boolean
    author?: XOR<UserWhereInput, UserRelationFilter>
    authorId?: IntFilter | number
  }

  export type PostOrderByInput = {
    id?: SortOrder
    createdAt?: SortOrder
    title?: SortOrder
    content?: SortOrder
    published?: SortOrder
    authorId?: SortOrder
  }

  export type PostWhereUniqueInput = {
    id?: number
  }

  export type UserWhereInput = {
    AND?: Enumerable<UserWhereInput>
    OR?: Enumerable<UserWhereInput>
    NOT?: Enumerable<UserWhereInput>
    id?: IntFilter | number
    email?: StringFilter | string
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
    posts?: PostListRelationFilter
  }

  export type UserOrderByInput = {
    id?: SortOrder
    email?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type UserWhereUniqueInput = {
    id?: number
    email?: string
  }

  export type MWhereInput = {
    AND?: Enumerable<MWhereInput>
    OR?: Enumerable<MWhereInput>
    NOT?: Enumerable<MWhereInput>
    id?: IntFilter | number
    n?: NListRelationFilter
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type MOrderByInput = {
    id?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type MWhereUniqueInput = {
    id?: number
  }

  export type NWhereInput = {
    AND?: Enumerable<NWhereInput>
    OR?: Enumerable<NWhereInput>
    NOT?: Enumerable<NWhereInput>
    id?: IntFilter | number
    m?: MListRelationFilter
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type NOrderByInput = {
    id?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type NWhereUniqueInput = {
    id?: number
  }

  export type OneOptionalWhereInput = {
    AND?: Enumerable<OneOptionalWhereInput>
    OR?: Enumerable<OneOptionalWhereInput>
    NOT?: Enumerable<OneOptionalWhereInput>
    id?: IntFilter | number
    many?: ManyRequiredListRelationFilter
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type OneOptionalOrderByInput = {
    id?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type OneOptionalWhereUniqueInput = {
    id?: number
  }

  export type ManyRequiredWhereInput = {
    AND?: Enumerable<ManyRequiredWhereInput>
    OR?: Enumerable<ManyRequiredWhereInput>
    NOT?: Enumerable<ManyRequiredWhereInput>
    id?: IntFilter | number
    one?: XOR<OneOptionalWhereInput, OneOptionalRelationFilter> | null
    oneOptionalId?: IntNullableFilter | number | null
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type ManyRequiredOrderByInput = {
    id?: SortOrder
    oneOptionalId?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type ManyRequiredWhereUniqueInput = {
    id?: number
  }

  export type OptionalSide1WhereInput = {
    AND?: Enumerable<OptionalSide1WhereInput>
    OR?: Enumerable<OptionalSide1WhereInput>
    NOT?: Enumerable<OptionalSide1WhereInput>
    id?: IntFilter | number
    opti?: XOR<OptionalSide2WhereInput, OptionalSide2RelationFilter> | null
    optionalSide2Id?: IntNullableFilter | number | null
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type OptionalSide1OrderByInput = {
    id?: SortOrder
    optionalSide2Id?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type OptionalSide1WhereUniqueInput = {
    id?: number
  }

  export type OptionalSide2WhereInput = {
    AND?: Enumerable<OptionalSide2WhereInput>
    OR?: Enumerable<OptionalSide2WhereInput>
    NOT?: Enumerable<OptionalSide2WhereInput>
    id?: IntFilter | number
    opti?: XOR<OptionalSide1WhereInput, OptionalSide1RelationFilter> | null
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type OptionalSide2OrderByInput = {
    id?: SortOrder
    int?: SortOrder
    optionalInt?: SortOrder
    float?: SortOrder
    optionalFloat?: SortOrder
    string?: SortOrder
    optionalString?: SortOrder
    json?: SortOrder
    optionalJson?: SortOrder
    enum?: SortOrder
    optionalEnum?: SortOrder
    boolean?: SortOrder
    optionalBoolean?: SortOrder
  }

  export type OptionalSide2WhereUniqueInput = {
    id?: number
  }

  export type AWhereInput = {
    AND?: Enumerable<AWhereInput>
    OR?: Enumerable<AWhereInput>
    NOT?: Enumerable<AWhereInput>
    id?: StringFilter | string
    email?: StringFilter | string
    name?: StringNullableFilter | string | null
    int?: IntFilter | number
    sInt?: IntFilter | number
    bInt?: BigIntFilter | BigInt | number
    serial?: IntFilter | number
    sSerial?: IntFilter | number
    bSerial?: IntFilter | number
    inc_int?: IntFilter | number
    inc_sInt?: IntFilter | number
    inc_bInt?: BigIntFilter | BigInt | number
  }

  export type AOrderByInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    int?: SortOrder
    sInt?: SortOrder
    bInt?: SortOrder
    serial?: SortOrder
    sSerial?: SortOrder
    bSerial?: SortOrder
    inc_int?: SortOrder
    inc_sInt?: SortOrder
    inc_bInt?: SortOrder
  }

  export type AWhereUniqueInput = {
    id?: string
    email?: string
  }

  export type BWhereInput = {
    AND?: Enumerable<BWhereInput>
    OR?: Enumerable<BWhereInput>
    NOT?: Enumerable<BWhereInput>
    id?: StringFilter | string
    float?: FloatFilter | number
    dFloat?: FloatFilter | number
    decFloat?: DecimalFilter | Decimal | number | string
    numFloat?: DecimalFilter | Decimal | number | string
  }

  export type BOrderByInput = {
    id?: SortOrder
    float?: SortOrder
    dFloat?: SortOrder
    decFloat?: SortOrder
    numFloat?: SortOrder
  }

  export type BWhereUniqueInput = {
    id?: string
  }

  export type CWhereInput = {
    AND?: Enumerable<CWhereInput>
    OR?: Enumerable<CWhereInput>
    NOT?: Enumerable<CWhereInput>
    id?: StringFilter | string
    char?: StringFilter | string
    vChar?: StringFilter | string
    text?: StringFilter | string
    bit?: StringFilter | string
    vBit?: StringFilter | string
    uuid?: StringFilter | string
  }

  export type COrderByInput = {
    id?: SortOrder
    char?: SortOrder
    vChar?: SortOrder
    text?: SortOrder
    bit?: SortOrder
    vBit?: SortOrder
    uuid?: SortOrder
  }

  export type CWhereUniqueInput = {
    id?: string
  }

  export type DWhereInput = {
    AND?: Enumerable<DWhereInput>
    OR?: Enumerable<DWhereInput>
    NOT?: Enumerable<DWhereInput>
    id?: StringFilter | string
    bool?: BoolFilter | boolean
    byteA?: BytesFilter | Buffer
    xml?: StringFilter | string
    json?: JsonFilter
    jsonb?: JsonFilter
  }

  export type DOrderByInput = {
    id?: SortOrder
    bool?: SortOrder
    byteA?: SortOrder
    xml?: SortOrder
    json?: SortOrder
    jsonb?: SortOrder
  }

  export type DWhereUniqueInput = {
    id?: string
  }

  export type EWhereInput = {
    AND?: Enumerable<EWhereInput>
    OR?: Enumerable<EWhereInput>
    NOT?: Enumerable<EWhereInput>
    id?: StringFilter | string
    date?: DateTimeFilter | Date | string
    time?: DateTimeFilter | Date | string
    ts?: DateTimeFilter | Date | string
  }

  export type EOrderByInput = {
    id?: SortOrder
    date?: SortOrder
    time?: SortOrder
    ts?: SortOrder
  }

  export type EWhereUniqueInput = {
    id?: string
  }

  export type PostCreateInput = {
    createdAt?: Date | string
    title: string
    content?: string | null
    published?: boolean
    author: UserCreateOneWithoutPostsInput
  }

  export type PostUncheckedCreateInput = {
    id?: number
    createdAt?: Date | string
    title: string
    content?: string | null
    published?: boolean
    authorId: number
  }

  export type PostUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
    author?: UserUpdateOneRequiredWithoutPostsInput
  }

  export type PostUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
    authorId?: IntFieldUpdateOperationsInput | number
  }

  export type PostUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PostUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
    authorId?: IntFieldUpdateOperationsInput | number
  }

  export type UserCreateInput = {
    email: string
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    posts?: PostCreateManyWithoutAuthorInput
  }

  export type UserUncheckedCreateInput = {
    id?: number
    email: string
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    posts?: PostUncheckedCreateManyWithoutAuthorInput
  }

  export type UserUpdateInput = {
    email?: StringFieldUpdateOperationsInput | string
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    posts?: PostUpdateManyWithoutAuthorInput
  }

  export type UserUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    posts?: PostUncheckedUpdateManyWithoutAuthorInput
  }

  export type UserUpdateManyMutationInput = {
    email?: StringFieldUpdateOperationsInput | string
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type UserUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type MCreateInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    n?: NCreateManyWithoutMInput
  }

  export type MUncheckedCreateInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type MUpdateInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    n?: NUpdateManyWithoutMInput
  }

  export type MUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type MUpdateManyMutationInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type MUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type NCreateInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    m?: MCreateManyWithoutNInput
  }

  export type NUncheckedCreateInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type NUpdateInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    m?: MUpdateManyWithoutNInput
  }

  export type NUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type NUpdateManyMutationInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type NUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OneOptionalCreateInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    many?: ManyRequiredCreateManyWithoutOneInput
  }

  export type OneOptionalUncheckedCreateInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    many?: ManyRequiredUncheckedCreateManyWithoutOneInput
  }

  export type OneOptionalUpdateInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    many?: ManyRequiredUpdateManyWithoutOneInput
  }

  export type OneOptionalUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    many?: ManyRequiredUncheckedUpdateManyWithoutOneInput
  }

  export type OneOptionalUpdateManyMutationInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OneOptionalUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ManyRequiredCreateInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    one?: OneOptionalCreateOneWithoutManyInput
  }

  export type ManyRequiredUncheckedCreateInput = {
    id?: number
    oneOptionalId?: number | null
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type ManyRequiredUpdateInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    one?: OneOptionalUpdateOneWithoutManyInput
  }

  export type ManyRequiredUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    oneOptionalId?: NullableIntFieldUpdateOperationsInput | number | null
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ManyRequiredUpdateManyMutationInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ManyRequiredUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    oneOptionalId?: NullableIntFieldUpdateOperationsInput | number | null
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide1CreateInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    opti?: OptionalSide2CreateOneWithoutOptiInput
  }

  export type OptionalSide1UncheckedCreateInput = {
    id?: number
    optionalSide2Id?: number | null
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OptionalSide1UpdateInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    opti?: OptionalSide2UpdateOneWithoutOptiInput
  }

  export type OptionalSide1UncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    optionalSide2Id?: NullableIntFieldUpdateOperationsInput | number | null
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide1UpdateManyMutationInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide1UncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    optionalSide2Id?: NullableIntFieldUpdateOperationsInput | number | null
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide2CreateInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    opti?: OptionalSide1CreateOneWithoutOptiInput
  }

  export type OptionalSide2UncheckedCreateInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
    opti?: OptionalSide1UncheckedCreateOneWithoutOptiInput
  }

  export type OptionalSide2UpdateInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    opti?: OptionalSide1UpdateOneWithoutOptiInput
  }

  export type OptionalSide2UncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
    opti?: OptionalSide1UncheckedUpdateOneWithoutOptiInput
  }

  export type OptionalSide2UpdateManyMutationInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide2UncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ACreateInput = {
    id?: string
    email: string
    name?: string | null
    int: number
    sInt: number
    bInt: BigInt | number
    serial?: number
    sSerial?: number
    bSerial?: number
    inc_int?: number
    inc_sInt?: number
    inc_bInt?: BigInt | number
  }

  export type AUncheckedCreateInput = {
    id?: string
    email: string
    name?: string | null
    int: number
    sInt: number
    bInt: BigInt | number
    serial?: number
    sSerial?: number
    bSerial?: number
    inc_int?: number
    inc_sInt?: number
    inc_bInt?: BigInt | number
  }

  export type AUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    int?: IntFieldUpdateOperationsInput | number
    sInt?: IntFieldUpdateOperationsInput | number
    bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
    serial?: IntFieldUpdateOperationsInput | number
    sSerial?: IntFieldUpdateOperationsInput | number
    bSerial?: IntFieldUpdateOperationsInput | number
    inc_int?: IntFieldUpdateOperationsInput | number
    inc_sInt?: IntFieldUpdateOperationsInput | number
    inc_bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
  }

  export type AUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    int?: IntFieldUpdateOperationsInput | number
    sInt?: IntFieldUpdateOperationsInput | number
    bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
    serial?: IntFieldUpdateOperationsInput | number
    sSerial?: IntFieldUpdateOperationsInput | number
    bSerial?: IntFieldUpdateOperationsInput | number
    inc_int?: IntFieldUpdateOperationsInput | number
    inc_sInt?: IntFieldUpdateOperationsInput | number
    inc_bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
  }

  export type AUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    int?: IntFieldUpdateOperationsInput | number
    sInt?: IntFieldUpdateOperationsInput | number
    bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
    serial?: IntFieldUpdateOperationsInput | number
    sSerial?: IntFieldUpdateOperationsInput | number
    bSerial?: IntFieldUpdateOperationsInput | number
    inc_int?: IntFieldUpdateOperationsInput | number
    inc_sInt?: IntFieldUpdateOperationsInput | number
    inc_bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
  }

  export type AUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    int?: IntFieldUpdateOperationsInput | number
    sInt?: IntFieldUpdateOperationsInput | number
    bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
    serial?: IntFieldUpdateOperationsInput | number
    sSerial?: IntFieldUpdateOperationsInput | number
    bSerial?: IntFieldUpdateOperationsInput | number
    inc_int?: IntFieldUpdateOperationsInput | number
    inc_sInt?: IntFieldUpdateOperationsInput | number
    inc_bInt?: BigIntFieldUpdateOperationsInput | BigInt | number
  }

  export type BCreateInput = {
    id?: string
    float: number
    dFloat: number
    decFloat: Decimal | number | string
    numFloat: Decimal | number | string
  }

  export type BUncheckedCreateInput = {
    id?: string
    float: number
    dFloat: number
    decFloat: Decimal | number | string
    numFloat: Decimal | number | string
  }

  export type BUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    float?: FloatFieldUpdateOperationsInput | number
    dFloat?: FloatFieldUpdateOperationsInput | number
    decFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
    numFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
  }

  export type BUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    float?: FloatFieldUpdateOperationsInput | number
    dFloat?: FloatFieldUpdateOperationsInput | number
    decFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
    numFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
  }

  export type BUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    float?: FloatFieldUpdateOperationsInput | number
    dFloat?: FloatFieldUpdateOperationsInput | number
    decFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
    numFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
  }

  export type BUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    float?: FloatFieldUpdateOperationsInput | number
    dFloat?: FloatFieldUpdateOperationsInput | number
    decFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
    numFloat?: DecimalFieldUpdateOperationsInput | Decimal | number | string
  }

  export type CCreateInput = {
    id?: string
    char: string
    vChar: string
    text: string
    bit: string
    vBit: string
    uuid: string
  }

  export type CUncheckedCreateInput = {
    id?: string
    char: string
    vChar: string
    text: string
    bit: string
    vBit: string
    uuid: string
  }

  export type CUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    char?: StringFieldUpdateOperationsInput | string
    vChar?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    bit?: StringFieldUpdateOperationsInput | string
    vBit?: StringFieldUpdateOperationsInput | string
    uuid?: StringFieldUpdateOperationsInput | string
  }

  export type CUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    char?: StringFieldUpdateOperationsInput | string
    vChar?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    bit?: StringFieldUpdateOperationsInput | string
    vBit?: StringFieldUpdateOperationsInput | string
    uuid?: StringFieldUpdateOperationsInput | string
  }

  export type CUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    char?: StringFieldUpdateOperationsInput | string
    vChar?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    bit?: StringFieldUpdateOperationsInput | string
    vBit?: StringFieldUpdateOperationsInput | string
    uuid?: StringFieldUpdateOperationsInput | string
  }

  export type CUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    char?: StringFieldUpdateOperationsInput | string
    vChar?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    bit?: StringFieldUpdateOperationsInput | string
    vBit?: StringFieldUpdateOperationsInput | string
    uuid?: StringFieldUpdateOperationsInput | string
  }

  export type DCreateInput = {
    id?: string
    bool: boolean
    byteA: Buffer
    xml: string
    json: InputJsonValue
    jsonb: InputJsonValue
  }

  export type DUncheckedCreateInput = {
    id?: string
    bool: boolean
    byteA: Buffer
    xml: string
    json: InputJsonValue
    jsonb: InputJsonValue
  }

  export type DUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    bool?: BoolFieldUpdateOperationsInput | boolean
    byteA?: BytesFieldUpdateOperationsInput | Buffer
    xml?: StringFieldUpdateOperationsInput | string
    json?: InputJsonValue
    jsonb?: InputJsonValue
  }

  export type DUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    bool?: BoolFieldUpdateOperationsInput | boolean
    byteA?: BytesFieldUpdateOperationsInput | Buffer
    xml?: StringFieldUpdateOperationsInput | string
    json?: InputJsonValue
    jsonb?: InputJsonValue
  }

  export type DUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    bool?: BoolFieldUpdateOperationsInput | boolean
    byteA?: BytesFieldUpdateOperationsInput | Buffer
    xml?: StringFieldUpdateOperationsInput | string
    json?: InputJsonValue
    jsonb?: InputJsonValue
  }

  export type DUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    bool?: BoolFieldUpdateOperationsInput | boolean
    byteA?: BytesFieldUpdateOperationsInput | Buffer
    xml?: StringFieldUpdateOperationsInput | string
    json?: InputJsonValue
    jsonb?: InputJsonValue
  }

  export type ECreateInput = {
    id?: string
    date: Date | string
    time: Date | string
    ts: Date | string
  }

  export type EUncheckedCreateInput = {
    id?: string
    date: Date | string
    time: Date | string
    ts: Date | string
  }

  export type EUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    ts?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    ts?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    ts?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    time?: DateTimeFieldUpdateOperationsInput | Date | string
    ts?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type IntFilter = {
    equals?: number
    in?: Enumerable<number>
    notIn?: Enumerable<number>
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedIntFilter | number
  }

  export type DateTimeFilter = {
    equals?: Date | string
    in?: Enumerable<Date> | Enumerable<string>
    notIn?: Enumerable<Date> | Enumerable<string>
    lt?: Date | string
    lte?: Date | string
    gt?: Date | string
    gte?: Date | string
    not?: NestedDateTimeFilter | Date | string
  }

  export type StringFilter = {
    equals?: string
    in?: Enumerable<string>
    notIn?: Enumerable<string>
    lt?: string
    lte?: string
    gt?: string
    gte?: string
    contains?: string
    startsWith?: string
    endsWith?: string
    mode?: QueryMode
    not?: NestedStringFilter | string
  }

  export type StringNullableFilter = {
    equals?: string | null
    in?: Enumerable<string> | null
    notIn?: Enumerable<string> | null
    lt?: string
    lte?: string
    gt?: string
    gte?: string
    contains?: string
    startsWith?: string
    endsWith?: string
    mode?: QueryMode
    not?: NestedStringNullableFilter | string | null
  }

  export type BoolFilter = {
    equals?: boolean
    not?: NestedBoolFilter | boolean
  }

  export type UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type IntNullableFilter = {
    equals?: number | null
    in?: Enumerable<number> | null
    notIn?: Enumerable<number> | null
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedIntNullableFilter | number | null
  }

  export type FloatFilter = {
    equals?: number
    in?: Enumerable<number>
    notIn?: Enumerable<number>
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedFloatFilter | number
  }

  export type FloatNullableFilter = {
    equals?: number | null
    in?: Enumerable<number> | null
    notIn?: Enumerable<number> | null
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedFloatNullableFilter | number | null
  }

  export type JsonFilter = {
    equals?: InputJsonValue
    not?: InputJsonValue
  }

  export type JsonNullableFilter = {
    equals?: InputJsonValue | null
    not?: InputJsonValue | null
  }

  export type EnumABeautifulEnumFilter = {
    equals?: ABeautifulEnum
    in?: Enumerable<ABeautifulEnum>
    notIn?: Enumerable<ABeautifulEnum>
    not?: NestedEnumABeautifulEnumFilter | ABeautifulEnum
  }

  export type EnumABeautifulEnumNullableFilter = {
    equals?: ABeautifulEnum | null
    in?: Enumerable<ABeautifulEnum> | null
    notIn?: Enumerable<ABeautifulEnum> | null
    not?: NestedEnumABeautifulEnumNullableFilter | ABeautifulEnum | null
  }

  export type BoolNullableFilter = {
    equals?: boolean | null
    not?: NestedBoolNullableFilter | boolean | null
  }

  export type PostListRelationFilter = {
    every?: PostWhereInput
    some?: PostWhereInput
    none?: PostWhereInput
  }

  export type NListRelationFilter = {
    every?: NWhereInput
    some?: NWhereInput
    none?: NWhereInput
  }

  export type MListRelationFilter = {
    every?: MWhereInput
    some?: MWhereInput
    none?: MWhereInput
  }

  export type ManyRequiredListRelationFilter = {
    every?: ManyRequiredWhereInput
    some?: ManyRequiredWhereInput
    none?: ManyRequiredWhereInput
  }

  export type OneOptionalRelationFilter = {
    is?: OneOptionalWhereInput | null
    isNot?: OneOptionalWhereInput | null
  }

  export type OptionalSide2RelationFilter = {
    is?: OptionalSide2WhereInput | null
    isNot?: OptionalSide2WhereInput | null
  }

  export type OptionalSide1RelationFilter = {
    is?: OptionalSide1WhereInput | null
    isNot?: OptionalSide1WhereInput | null
  }

  export type BigIntFilter = {
    equals?: BigInt | number
    in?: Enumerable<BigInt> | Enumerable<number>
    notIn?: Enumerable<BigInt> | Enumerable<number>
    lt?: BigInt | number
    lte?: BigInt | number
    gt?: BigInt | number
    gte?: BigInt | number
    not?: NestedBigIntFilter | BigInt | number
  }

  export type DecimalFilter = {
    equals?: Decimal | number | string
    in?: Enumerable<Decimal> | Enumerable<number> | Enumerable<string>
    notIn?: Enumerable<Decimal> | Enumerable<number> | Enumerable<string>
    lt?: Decimal | number | string
    lte?: Decimal | number | string
    gt?: Decimal | number | string
    gte?: Decimal | number | string
    not?: NestedDecimalFilter | Decimal | number | string
  }

  export type BytesFilter = {
    equals?: Buffer
    not?: NestedBytesFilter | Buffer
  }

  export type UserCreateOneWithoutPostsInput = {
    create?: XOR<UserUncheckedCreateWithoutPostsInput, UserCreateWithoutPostsInput>
    connect?: UserWhereUniqueInput
    connectOrCreate?: UserCreateOrConnectWithoutpostsInput
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type UserUpdateOneRequiredWithoutPostsInput = {
    create?: XOR<UserUncheckedCreateWithoutPostsInput, UserCreateWithoutPostsInput>
    connect?: UserWhereUniqueInput
    update?: XOR<UserUncheckedUpdateWithoutPostsInput, UserUpdateWithoutPostsInput>
    upsert?: UserUpsertWithoutPostsInput
    connectOrCreate?: UserCreateOrConnectWithoutpostsInput
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type PostCreateManyWithoutAuthorInput = {
    create?: XOR<Enumerable<PostUncheckedCreateWithoutAuthorInput>, Enumerable<PostCreateWithoutAuthorInput>>
    connect?: Enumerable<PostWhereUniqueInput>
    connectOrCreate?: Enumerable<PostCreateOrConnectWithoutauthorInput>
  }

  export type PostUncheckedCreateManyWithoutAuthorInput = {
    create?: XOR<Enumerable<PostUncheckedCreateWithoutAuthorInput>, Enumerable<PostCreateWithoutAuthorInput>>
    connect?: Enumerable<PostWhereUniqueInput>
    connectOrCreate?: Enumerable<PostCreateOrConnectWithoutauthorInput>
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type FloatFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NullableFloatFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type EnumABeautifulEnumFieldUpdateOperationsInput = {
    set?: ABeautifulEnum
  }

  export type NullableEnumABeautifulEnumFieldUpdateOperationsInput = {
    set?: ABeautifulEnum | null
  }

  export type NullableBoolFieldUpdateOperationsInput = {
    set?: boolean | null
  }

  export type PostUpdateManyWithoutAuthorInput = {
    create?: XOR<Enumerable<PostUncheckedCreateWithoutAuthorInput>, Enumerable<PostCreateWithoutAuthorInput>>
    connect?: Enumerable<PostWhereUniqueInput>
    set?: Enumerable<PostWhereUniqueInput>
    disconnect?: Enumerable<PostWhereUniqueInput>
    delete?: Enumerable<PostWhereUniqueInput>
    update?: Enumerable<PostUpdateWithWhereUniqueWithoutAuthorInput>
    updateMany?: Enumerable<PostUpdateManyWithWhereWithoutAuthorInput>
    deleteMany?: Enumerable<PostScalarWhereInput>
    upsert?: Enumerable<PostUpsertWithWhereUniqueWithoutAuthorInput>
    connectOrCreate?: Enumerable<PostCreateOrConnectWithoutauthorInput>
  }

  export type PostUncheckedUpdateManyWithoutAuthorInput = {
    create?: XOR<Enumerable<PostUncheckedCreateWithoutAuthorInput>, Enumerable<PostCreateWithoutAuthorInput>>
    connect?: Enumerable<PostWhereUniqueInput>
    set?: Enumerable<PostWhereUniqueInput>
    disconnect?: Enumerable<PostWhereUniqueInput>
    delete?: Enumerable<PostWhereUniqueInput>
    update?: Enumerable<PostUpdateWithWhereUniqueWithoutAuthorInput>
    updateMany?: Enumerable<PostUpdateManyWithWhereWithoutAuthorInput>
    deleteMany?: Enumerable<PostScalarWhereInput>
    upsert?: Enumerable<PostUpsertWithWhereUniqueWithoutAuthorInput>
    connectOrCreate?: Enumerable<PostCreateOrConnectWithoutauthorInput>
  }

  export type NCreateManyWithoutMInput = {
    create?: XOR<Enumerable<NUncheckedCreateWithoutMInput>, Enumerable<NCreateWithoutMInput>>
    connect?: Enumerable<NWhereUniqueInput>
    connectOrCreate?: Enumerable<NCreateOrConnectWithoutmInput>
  }

  export type NUpdateManyWithoutMInput = {
    create?: XOR<Enumerable<NUncheckedCreateWithoutMInput>, Enumerable<NCreateWithoutMInput>>
    connect?: Enumerable<NWhereUniqueInput>
    set?: Enumerable<NWhereUniqueInput>
    disconnect?: Enumerable<NWhereUniqueInput>
    delete?: Enumerable<NWhereUniqueInput>
    update?: Enumerable<NUpdateWithWhereUniqueWithoutMInput>
    updateMany?: Enumerable<NUpdateManyWithWhereWithoutMInput>
    deleteMany?: Enumerable<NScalarWhereInput>
    upsert?: Enumerable<NUpsertWithWhereUniqueWithoutMInput>
    connectOrCreate?: Enumerable<NCreateOrConnectWithoutmInput>
  }

  export type MCreateManyWithoutNInput = {
    create?: XOR<Enumerable<MUncheckedCreateWithoutNInput>, Enumerable<MCreateWithoutNInput>>
    connect?: Enumerable<MWhereUniqueInput>
    connectOrCreate?: Enumerable<MCreateOrConnectWithoutnInput>
  }

  export type MUpdateManyWithoutNInput = {
    create?: XOR<Enumerable<MUncheckedCreateWithoutNInput>, Enumerable<MCreateWithoutNInput>>
    connect?: Enumerable<MWhereUniqueInput>
    set?: Enumerable<MWhereUniqueInput>
    disconnect?: Enumerable<MWhereUniqueInput>
    delete?: Enumerable<MWhereUniqueInput>
    update?: Enumerable<MUpdateWithWhereUniqueWithoutNInput>
    updateMany?: Enumerable<MUpdateManyWithWhereWithoutNInput>
    deleteMany?: Enumerable<MScalarWhereInput>
    upsert?: Enumerable<MUpsertWithWhereUniqueWithoutNInput>
    connectOrCreate?: Enumerable<MCreateOrConnectWithoutnInput>
  }

  export type ManyRequiredCreateManyWithoutOneInput = {
    create?: XOR<Enumerable<ManyRequiredUncheckedCreateWithoutOneInput>, Enumerable<ManyRequiredCreateWithoutOneInput>>
    connect?: Enumerable<ManyRequiredWhereUniqueInput>
    connectOrCreate?: Enumerable<ManyRequiredCreateOrConnectWithoutoneInput>
  }

  export type ManyRequiredUncheckedCreateManyWithoutOneInput = {
    create?: XOR<Enumerable<ManyRequiredUncheckedCreateWithoutOneInput>, Enumerable<ManyRequiredCreateWithoutOneInput>>
    connect?: Enumerable<ManyRequiredWhereUniqueInput>
    connectOrCreate?: Enumerable<ManyRequiredCreateOrConnectWithoutoneInput>
  }

  export type ManyRequiredUpdateManyWithoutOneInput = {
    create?: XOR<Enumerable<ManyRequiredUncheckedCreateWithoutOneInput>, Enumerable<ManyRequiredCreateWithoutOneInput>>
    connect?: Enumerable<ManyRequiredWhereUniqueInput>
    set?: Enumerable<ManyRequiredWhereUniqueInput>
    disconnect?: Enumerable<ManyRequiredWhereUniqueInput>
    delete?: Enumerable<ManyRequiredWhereUniqueInput>
    update?: Enumerable<ManyRequiredUpdateWithWhereUniqueWithoutOneInput>
    updateMany?: Enumerable<ManyRequiredUpdateManyWithWhereWithoutOneInput>
    deleteMany?: Enumerable<ManyRequiredScalarWhereInput>
    upsert?: Enumerable<ManyRequiredUpsertWithWhereUniqueWithoutOneInput>
    connectOrCreate?: Enumerable<ManyRequiredCreateOrConnectWithoutoneInput>
  }

  export type ManyRequiredUncheckedUpdateManyWithoutOneInput = {
    create?: XOR<Enumerable<ManyRequiredUncheckedCreateWithoutOneInput>, Enumerable<ManyRequiredCreateWithoutOneInput>>
    connect?: Enumerable<ManyRequiredWhereUniqueInput>
    set?: Enumerable<ManyRequiredWhereUniqueInput>
    disconnect?: Enumerable<ManyRequiredWhereUniqueInput>
    delete?: Enumerable<ManyRequiredWhereUniqueInput>
    update?: Enumerable<ManyRequiredUpdateWithWhereUniqueWithoutOneInput>
    updateMany?: Enumerable<ManyRequiredUpdateManyWithWhereWithoutOneInput>
    deleteMany?: Enumerable<ManyRequiredScalarWhereInput>
    upsert?: Enumerable<ManyRequiredUpsertWithWhereUniqueWithoutOneInput>
    connectOrCreate?: Enumerable<ManyRequiredCreateOrConnectWithoutoneInput>
  }

  export type OneOptionalCreateOneWithoutManyInput = {
    create?: XOR<OneOptionalUncheckedCreateWithoutManyInput, OneOptionalCreateWithoutManyInput>
    connect?: OneOptionalWhereUniqueInput
    connectOrCreate?: OneOptionalCreateOrConnectWithoutmanyInput
  }

  export type OneOptionalUpdateOneWithoutManyInput = {
    create?: XOR<OneOptionalUncheckedCreateWithoutManyInput, OneOptionalCreateWithoutManyInput>
    connect?: OneOptionalWhereUniqueInput
    disconnect?: boolean
    delete?: boolean
    update?: XOR<OneOptionalUncheckedUpdateWithoutManyInput, OneOptionalUpdateWithoutManyInput>
    upsert?: OneOptionalUpsertWithoutManyInput
    connectOrCreate?: OneOptionalCreateOrConnectWithoutmanyInput
  }

  export type OptionalSide2CreateOneWithoutOptiInput = {
    create?: XOR<OptionalSide2UncheckedCreateWithoutOptiInput, OptionalSide2CreateWithoutOptiInput>
    connect?: OptionalSide2WhereUniqueInput
    connectOrCreate?: OptionalSide2CreateOrConnectWithoutoptiInput
  }

  export type OptionalSide2UpdateOneWithoutOptiInput = {
    create?: XOR<OptionalSide2UncheckedCreateWithoutOptiInput, OptionalSide2CreateWithoutOptiInput>
    connect?: OptionalSide2WhereUniqueInput
    disconnect?: boolean
    delete?: boolean
    update?: XOR<OptionalSide2UncheckedUpdateWithoutOptiInput, OptionalSide2UpdateWithoutOptiInput>
    upsert?: OptionalSide2UpsertWithoutOptiInput
    connectOrCreate?: OptionalSide2CreateOrConnectWithoutoptiInput
  }

  export type OptionalSide1CreateOneWithoutOptiInput = {
    create?: XOR<OptionalSide1UncheckedCreateWithoutOptiInput, OptionalSide1CreateWithoutOptiInput>
    connect?: OptionalSide1WhereUniqueInput
    connectOrCreate?: OptionalSide1CreateOrConnectWithoutoptiInput
  }

  export type OptionalSide1UncheckedCreateOneWithoutOptiInput = {
    create?: XOR<OptionalSide1UncheckedCreateWithoutOptiInput, OptionalSide1CreateWithoutOptiInput>
    connect?: OptionalSide1WhereUniqueInput
    connectOrCreate?: OptionalSide1CreateOrConnectWithoutoptiInput
  }

  export type OptionalSide1UpdateOneWithoutOptiInput = {
    create?: XOR<OptionalSide1UncheckedCreateWithoutOptiInput, OptionalSide1CreateWithoutOptiInput>
    connect?: OptionalSide1WhereUniqueInput
    disconnect?: boolean
    delete?: boolean
    update?: XOR<OptionalSide1UncheckedUpdateWithoutOptiInput, OptionalSide1UpdateWithoutOptiInput>
    upsert?: OptionalSide1UpsertWithoutOptiInput
    connectOrCreate?: OptionalSide1CreateOrConnectWithoutoptiInput
  }

  export type OptionalSide1UncheckedUpdateOneWithoutOptiInput = {
    create?: XOR<OptionalSide1UncheckedCreateWithoutOptiInput, OptionalSide1CreateWithoutOptiInput>
    connect?: OptionalSide1WhereUniqueInput
    disconnect?: boolean
    delete?: boolean
    update?: XOR<OptionalSide1UncheckedUpdateWithoutOptiInput, OptionalSide1UpdateWithoutOptiInput>
    upsert?: OptionalSide1UpsertWithoutOptiInput
    connectOrCreate?: OptionalSide1CreateOrConnectWithoutoptiInput
  }

  export type BigIntFieldUpdateOperationsInput = {
    set?: BigInt | number
    increment?: BigInt | number
    decrement?: BigInt | number
    multiply?: BigInt | number
    divide?: BigInt | number
  }

  export type DecimalFieldUpdateOperationsInput = {
    set?: Decimal | number | string
    increment?: Decimal | number | string
    decrement?: Decimal | number | string
    multiply?: Decimal | number | string
    divide?: Decimal | number | string
  }

  export type BytesFieldUpdateOperationsInput = {
    set?: Buffer
  }

  export type NestedIntFilter = {
    equals?: number
    in?: Enumerable<number>
    notIn?: Enumerable<number>
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedIntFilter | number
  }

  export type NestedDateTimeFilter = {
    equals?: Date | string
    in?: Enumerable<Date> | Enumerable<string>
    notIn?: Enumerable<Date> | Enumerable<string>
    lt?: Date | string
    lte?: Date | string
    gt?: Date | string
    gte?: Date | string
    not?: NestedDateTimeFilter | Date | string
  }

  export type NestedStringFilter = {
    equals?: string
    in?: Enumerable<string>
    notIn?: Enumerable<string>
    lt?: string
    lte?: string
    gt?: string
    gte?: string
    contains?: string
    startsWith?: string
    endsWith?: string
    not?: NestedStringFilter | string
  }

  export type NestedStringNullableFilter = {
    equals?: string | null
    in?: Enumerable<string> | null
    notIn?: Enumerable<string> | null
    lt?: string
    lte?: string
    gt?: string
    gte?: string
    contains?: string
    startsWith?: string
    endsWith?: string
    not?: NestedStringNullableFilter | string | null
  }

  export type NestedBoolFilter = {
    equals?: boolean
    not?: NestedBoolFilter | boolean
  }

  export type NestedIntNullableFilter = {
    equals?: number | null
    in?: Enumerable<number> | null
    notIn?: Enumerable<number> | null
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedIntNullableFilter | number | null
  }

  export type NestedFloatFilter = {
    equals?: number
    in?: Enumerable<number>
    notIn?: Enumerable<number>
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedFloatFilter | number
  }

  export type NestedFloatNullableFilter = {
    equals?: number | null
    in?: Enumerable<number> | null
    notIn?: Enumerable<number> | null
    lt?: number
    lte?: number
    gt?: number
    gte?: number
    not?: NestedFloatNullableFilter | number | null
  }

  export type NestedEnumABeautifulEnumFilter = {
    equals?: ABeautifulEnum
    in?: Enumerable<ABeautifulEnum>
    notIn?: Enumerable<ABeautifulEnum>
    not?: NestedEnumABeautifulEnumFilter | ABeautifulEnum
  }

  export type NestedEnumABeautifulEnumNullableFilter = {
    equals?: ABeautifulEnum | null
    in?: Enumerable<ABeautifulEnum> | null
    notIn?: Enumerable<ABeautifulEnum> | null
    not?: NestedEnumABeautifulEnumNullableFilter | ABeautifulEnum | null
  }

  export type NestedBoolNullableFilter = {
    equals?: boolean | null
    not?: NestedBoolNullableFilter | boolean | null
  }

  export type NestedBigIntFilter = {
    equals?: BigInt | number
    in?: Enumerable<BigInt> | Enumerable<number>
    notIn?: Enumerable<BigInt> | Enumerable<number>
    lt?: BigInt | number
    lte?: BigInt | number
    gt?: BigInt | number
    gte?: BigInt | number
    not?: NestedBigIntFilter | BigInt | number
  }

  export type NestedDecimalFilter = {
    equals?: Decimal | number | string
    in?: Enumerable<Decimal> | Enumerable<number> | Enumerable<string>
    notIn?: Enumerable<Decimal> | Enumerable<number> | Enumerable<string>
    lt?: Decimal | number | string
    lte?: Decimal | number | string
    gt?: Decimal | number | string
    gte?: Decimal | number | string
    not?: NestedDecimalFilter | Decimal | number | string
  }

  export type NestedBytesFilter = {
    equals?: Buffer
    not?: NestedBytesFilter | Buffer
  }

  export type UserCreateWithoutPostsInput = {
    email: string
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type UserUncheckedCreateWithoutPostsInput = {
    id?: number
    email: string
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type UserCreateOrConnectWithoutpostsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserUncheckedCreateWithoutPostsInput, UserCreateWithoutPostsInput>
  }

  export type UserUpdateWithoutPostsInput = {
    email?: StringFieldUpdateOperationsInput | string
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type UserUncheckedUpdateWithoutPostsInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type UserUpsertWithoutPostsInput = {
    update: XOR<UserUncheckedUpdateWithoutPostsInput, UserUpdateWithoutPostsInput>
    create: XOR<UserUncheckedCreateWithoutPostsInput, UserCreateWithoutPostsInput>
  }

  export type PostCreateWithoutAuthorInput = {
    createdAt?: Date | string
    title: string
    content?: string | null
    published?: boolean
  }

  export type PostUncheckedCreateWithoutAuthorInput = {
    id?: number
    createdAt?: Date | string
    title: string
    content?: string | null
    published?: boolean
  }

  export type PostCreateOrConnectWithoutauthorInput = {
    where: PostWhereUniqueInput
    create: XOR<PostUncheckedCreateWithoutAuthorInput, PostCreateWithoutAuthorInput>
  }

  export type PostUpdateWithWhereUniqueWithoutAuthorInput = {
    where: PostWhereUniqueInput
    data: XOR<PostUncheckedUpdateWithoutAuthorInput, PostUpdateWithoutAuthorInput>
  }

  export type PostUpdateManyWithWhereWithoutAuthorInput = {
    where: PostScalarWhereInput
    data: XOR<PostUncheckedUpdateManyWithoutPostsInput, PostUpdateManyMutationInput>
  }

  export type PostScalarWhereInput = {
    AND?: Enumerable<PostScalarWhereInput>
    OR?: Enumerable<PostScalarWhereInput>
    NOT?: Enumerable<PostScalarWhereInput>
    id?: IntFilter | number
    createdAt?: DateTimeFilter | Date | string
    title?: StringFilter | string
    content?: StringNullableFilter | string | null
    published?: BoolFilter | boolean
    authorId?: IntFilter | number
  }

  export type PostUpsertWithWhereUniqueWithoutAuthorInput = {
    where: PostWhereUniqueInput
    update: XOR<PostUncheckedUpdateWithoutAuthorInput, PostUpdateWithoutAuthorInput>
    create: XOR<PostUncheckedCreateWithoutAuthorInput, PostCreateWithoutAuthorInput>
  }

  export type NCreateWithoutMInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type NUncheckedCreateWithoutMInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type NCreateOrConnectWithoutmInput = {
    where: NWhereUniqueInput
    create: XOR<NUncheckedCreateWithoutMInput, NCreateWithoutMInput>
  }

  export type NUpdateWithWhereUniqueWithoutMInput = {
    where: NWhereUniqueInput
    data: XOR<NUncheckedUpdateWithoutMInput, NUpdateWithoutMInput>
  }

  export type NUpdateManyWithWhereWithoutMInput = {
    where: NScalarWhereInput
    data: XOR<NUncheckedUpdateManyWithoutNInput, NUpdateManyMutationInput>
  }

  export type NScalarWhereInput = {
    AND?: Enumerable<NScalarWhereInput>
    OR?: Enumerable<NScalarWhereInput>
    NOT?: Enumerable<NScalarWhereInput>
    id?: IntFilter | number
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type NUpsertWithWhereUniqueWithoutMInput = {
    where: NWhereUniqueInput
    update: XOR<NUncheckedUpdateWithoutMInput, NUpdateWithoutMInput>
    create: XOR<NUncheckedCreateWithoutMInput, NCreateWithoutMInput>
  }

  export type MCreateWithoutNInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type MUncheckedCreateWithoutNInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type MCreateOrConnectWithoutnInput = {
    where: MWhereUniqueInput
    create: XOR<MUncheckedCreateWithoutNInput, MCreateWithoutNInput>
  }

  export type MUpdateWithWhereUniqueWithoutNInput = {
    where: MWhereUniqueInput
    data: XOR<MUncheckedUpdateWithoutNInput, MUpdateWithoutNInput>
  }

  export type MUpdateManyWithWhereWithoutNInput = {
    where: MScalarWhereInput
    data: XOR<MUncheckedUpdateManyWithoutMInput, MUpdateManyMutationInput>
  }

  export type MScalarWhereInput = {
    AND?: Enumerable<MScalarWhereInput>
    OR?: Enumerable<MScalarWhereInput>
    NOT?: Enumerable<MScalarWhereInput>
    id?: IntFilter | number
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type MUpsertWithWhereUniqueWithoutNInput = {
    where: MWhereUniqueInput
    update: XOR<MUncheckedUpdateWithoutNInput, MUpdateWithoutNInput>
    create: XOR<MUncheckedCreateWithoutNInput, MCreateWithoutNInput>
  }

  export type ManyRequiredCreateWithoutOneInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type ManyRequiredUncheckedCreateWithoutOneInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type ManyRequiredCreateOrConnectWithoutoneInput = {
    where: ManyRequiredWhereUniqueInput
    create: XOR<ManyRequiredUncheckedCreateWithoutOneInput, ManyRequiredCreateWithoutOneInput>
  }

  export type ManyRequiredUpdateWithWhereUniqueWithoutOneInput = {
    where: ManyRequiredWhereUniqueInput
    data: XOR<ManyRequiredUncheckedUpdateWithoutOneInput, ManyRequiredUpdateWithoutOneInput>
  }

  export type ManyRequiredUpdateManyWithWhereWithoutOneInput = {
    where: ManyRequiredScalarWhereInput
    data: XOR<ManyRequiredUncheckedUpdateManyWithoutManyInput, ManyRequiredUpdateManyMutationInput>
  }

  export type ManyRequiredScalarWhereInput = {
    AND?: Enumerable<ManyRequiredScalarWhereInput>
    OR?: Enumerable<ManyRequiredScalarWhereInput>
    NOT?: Enumerable<ManyRequiredScalarWhereInput>
    id?: IntFilter | number
    oneOptionalId?: IntNullableFilter | number | null
    int?: IntFilter | number
    optionalInt?: IntNullableFilter | number | null
    float?: FloatFilter | number
    optionalFloat?: FloatNullableFilter | number | null
    string?: StringFilter | string
    optionalString?: StringNullableFilter | string | null
    json?: JsonFilter
    optionalJson?: JsonNullableFilter
    enum?: EnumABeautifulEnumFilter | ABeautifulEnum
    optionalEnum?: EnumABeautifulEnumNullableFilter | ABeautifulEnum | null
    boolean?: BoolFilter | boolean
    optionalBoolean?: BoolNullableFilter | boolean | null
  }

  export type ManyRequiredUpsertWithWhereUniqueWithoutOneInput = {
    where: ManyRequiredWhereUniqueInput
    update: XOR<ManyRequiredUncheckedUpdateWithoutOneInput, ManyRequiredUpdateWithoutOneInput>
    create: XOR<ManyRequiredUncheckedCreateWithoutOneInput, ManyRequiredCreateWithoutOneInput>
  }

  export type OneOptionalCreateWithoutManyInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OneOptionalUncheckedCreateWithoutManyInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OneOptionalCreateOrConnectWithoutmanyInput = {
    where: OneOptionalWhereUniqueInput
    create: XOR<OneOptionalUncheckedCreateWithoutManyInput, OneOptionalCreateWithoutManyInput>
  }

  export type OneOptionalUpdateWithoutManyInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OneOptionalUncheckedUpdateWithoutManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OneOptionalUpsertWithoutManyInput = {
    update: XOR<OneOptionalUncheckedUpdateWithoutManyInput, OneOptionalUpdateWithoutManyInput>
    create: XOR<OneOptionalUncheckedCreateWithoutManyInput, OneOptionalCreateWithoutManyInput>
  }

  export type OptionalSide2CreateWithoutOptiInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OptionalSide2UncheckedCreateWithoutOptiInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OptionalSide2CreateOrConnectWithoutoptiInput = {
    where: OptionalSide2WhereUniqueInput
    create: XOR<OptionalSide2UncheckedCreateWithoutOptiInput, OptionalSide2CreateWithoutOptiInput>
  }

  export type OptionalSide2UpdateWithoutOptiInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide2UncheckedUpdateWithoutOptiInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide2UpsertWithoutOptiInput = {
    update: XOR<OptionalSide2UncheckedUpdateWithoutOptiInput, OptionalSide2UpdateWithoutOptiInput>
    create: XOR<OptionalSide2UncheckedCreateWithoutOptiInput, OptionalSide2CreateWithoutOptiInput>
  }

  export type OptionalSide1CreateWithoutOptiInput = {
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OptionalSide1UncheckedCreateWithoutOptiInput = {
    id?: number
    int: number
    optionalInt?: number | null
    float: number
    optionalFloat?: number | null
    string: string
    optionalString?: string | null
    json: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum: ABeautifulEnum
    optionalEnum?: ABeautifulEnum | null
    boolean: boolean
    optionalBoolean?: boolean | null
  }

  export type OptionalSide1CreateOrConnectWithoutoptiInput = {
    where: OptionalSide1WhereUniqueInput
    create: XOR<OptionalSide1UncheckedCreateWithoutOptiInput, OptionalSide1CreateWithoutOptiInput>
  }

  export type OptionalSide1UpdateWithoutOptiInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide1UncheckedUpdateWithoutOptiInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type OptionalSide1UpsertWithoutOptiInput = {
    update: XOR<OptionalSide1UncheckedUpdateWithoutOptiInput, OptionalSide1UpdateWithoutOptiInput>
    create: XOR<OptionalSide1UncheckedCreateWithoutOptiInput, OptionalSide1CreateWithoutOptiInput>
  }

  export type PostUpdateWithoutAuthorInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PostUncheckedUpdateWithoutAuthorInput = {
    id?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PostUncheckedUpdateManyWithoutPostsInput = {
    id?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    title?: StringFieldUpdateOperationsInput | string
    content?: NullableStringFieldUpdateOperationsInput | string | null
    published?: BoolFieldUpdateOperationsInput | boolean
  }

  export type NUpdateWithoutMInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type NUncheckedUpdateWithoutMInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type NUncheckedUpdateManyWithoutNInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type MUpdateWithoutNInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type MUncheckedUpdateWithoutNInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type MUncheckedUpdateManyWithoutMInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ManyRequiredUpdateWithoutOneInput = {
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ManyRequiredUncheckedUpdateWithoutOneInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }

  export type ManyRequiredUncheckedUpdateManyWithoutManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    int?: IntFieldUpdateOperationsInput | number
    optionalInt?: NullableIntFieldUpdateOperationsInput | number | null
    float?: FloatFieldUpdateOperationsInput | number
    optionalFloat?: NullableFloatFieldUpdateOperationsInput | number | null
    string?: StringFieldUpdateOperationsInput | string
    optionalString?: NullableStringFieldUpdateOperationsInput | string | null
    json?: InputJsonValue
    optionalJson?: InputJsonValue | null
    enum?: EnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum
    optionalEnum?: NullableEnumABeautifulEnumFieldUpdateOperationsInput | ABeautifulEnum | null
    boolean?: BoolFieldUpdateOperationsInput | boolean
    optionalBoolean?: NullableBoolFieldUpdateOperationsInput | boolean | null
  }



  /**
   * Batch Payload for updateMany & deleteMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.DMMF.Document;
}

/*
* Exports for compatibility introduced in 2.12.0
* Please import from the Prisma namespace instead
*/

/**
 * @deprecated Renamed to \`Prisma.PostScalarFieldEnum\`
 */
export type PostScalarFieldEnum = Prisma.PostScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.UserScalarFieldEnum\`
 */
export type UserScalarFieldEnum = Prisma.UserScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.MScalarFieldEnum\`
 */
export type MScalarFieldEnum = Prisma.MScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.NScalarFieldEnum\`
 */
export type NScalarFieldEnum = Prisma.NScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.OneOptionalScalarFieldEnum\`
 */
export type OneOptionalScalarFieldEnum = Prisma.OneOptionalScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredScalarFieldEnum\`
 */
export type ManyRequiredScalarFieldEnum = Prisma.ManyRequiredScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1ScalarFieldEnum\`
 */
export type OptionalSide1ScalarFieldEnum = Prisma.OptionalSide1ScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2ScalarFieldEnum\`
 */
export type OptionalSide2ScalarFieldEnum = Prisma.OptionalSide2ScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.AScalarFieldEnum\`
 */
export type AScalarFieldEnum = Prisma.AScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.BScalarFieldEnum\`
 */
export type BScalarFieldEnum = Prisma.BScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.CScalarFieldEnum\`
 */
export type CScalarFieldEnum = Prisma.CScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.DScalarFieldEnum\`
 */
export type DScalarFieldEnum = Prisma.DScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.EScalarFieldEnum\`
 */
export type EScalarFieldEnum = Prisma.EScalarFieldEnum

/**
 * @deprecated Renamed to \`Prisma.SortOrder\`
 */
export type SortOrder = Prisma.SortOrder

/**
 * @deprecated Renamed to \`Prisma.QueryMode\`
 */
export type QueryMode = Prisma.QueryMode

/**
 * @deprecated Renamed to \`Prisma.ModelName\`
 */
export type ModelName = Prisma.ModelName

/**
 * @deprecated Renamed to \`Prisma.AggregatePost\`
 */
export type AggregatePost = Prisma.AggregatePost

/**
 * @deprecated Renamed to \`Prisma.PostAvgAggregateOutputType\`
 */
export type PostAvgAggregateOutputType = Prisma.PostAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.PostSumAggregateOutputType\`
 */
export type PostSumAggregateOutputType = Prisma.PostSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.PostMinAggregateOutputType\`
 */
export type PostMinAggregateOutputType = Prisma.PostMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.PostMaxAggregateOutputType\`
 */
export type PostMaxAggregateOutputType = Prisma.PostMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.PostCountAggregateOutputType\`
 */
export type PostCountAggregateOutputType = Prisma.PostCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregatePostArgs\`
 */
export type AggregatePostArgs = Prisma.AggregatePostArgs

/**
 * @deprecated Renamed to \`Prisma.PostAvgAggregateInputType\`
 */
export type PostAvgAggregateInputType = Prisma.PostAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.PostSumAggregateInputType\`
 */
export type PostSumAggregateInputType = Prisma.PostSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.PostMinAggregateInputType\`
 */
export type PostMinAggregateInputType = Prisma.PostMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.PostMaxAggregateInputType\`
 */
export type PostMaxAggregateInputType = Prisma.PostMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.PostCountAggregateInputType\`
 */
export type PostCountAggregateInputType = Prisma.PostCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.PostSelect\`
 */
export type PostSelect = Prisma.PostSelect

/**
 * @deprecated Renamed to \`Prisma.PostInclude\`
 */
export type PostInclude = Prisma.PostInclude

/**
 * @deprecated Renamed to \`Prisma.FindUniquePostArgs\`
 */
export type FindUniquePostArgs = Prisma.FindUniquePostArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstPostArgs\`
 */
export type FindFirstPostArgs = Prisma.FindFirstPostArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyPostArgs\`
 */
export type FindManyPostArgs = Prisma.FindManyPostArgs

/**
 * @deprecated Renamed to \`Prisma.PostCreateArgs\`
 */
export type PostCreateArgs = Prisma.PostCreateArgs

/**
 * @deprecated Renamed to \`Prisma.PostUpdateArgs\`
 */
export type PostUpdateArgs = Prisma.PostUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.PostUpdateManyArgs\`
 */
export type PostUpdateManyArgs = Prisma.PostUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.PostUpsertArgs\`
 */
export type PostUpsertArgs = Prisma.PostUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.PostDeleteArgs\`
 */
export type PostDeleteArgs = Prisma.PostDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.PostDeleteManyArgs\`
 */
export type PostDeleteManyArgs = Prisma.PostDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateUser\`
 */
export type AggregateUser = Prisma.AggregateUser

/**
 * @deprecated Renamed to \`Prisma.UserAvgAggregateOutputType\`
 */
export type UserAvgAggregateOutputType = Prisma.UserAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.UserSumAggregateOutputType\`
 */
export type UserSumAggregateOutputType = Prisma.UserSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.UserMinAggregateOutputType\`
 */
export type UserMinAggregateOutputType = Prisma.UserMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.UserMaxAggregateOutputType\`
 */
export type UserMaxAggregateOutputType = Prisma.UserMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.UserCountAggregateOutputType\`
 */
export type UserCountAggregateOutputType = Prisma.UserCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateUserArgs\`
 */
export type AggregateUserArgs = Prisma.AggregateUserArgs

/**
 * @deprecated Renamed to \`Prisma.UserAvgAggregateInputType\`
 */
export type UserAvgAggregateInputType = Prisma.UserAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.UserSumAggregateInputType\`
 */
export type UserSumAggregateInputType = Prisma.UserSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.UserMinAggregateInputType\`
 */
export type UserMinAggregateInputType = Prisma.UserMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.UserMaxAggregateInputType\`
 */
export type UserMaxAggregateInputType = Prisma.UserMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.UserCountAggregateInputType\`
 */
export type UserCountAggregateInputType = Prisma.UserCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.UserSelect\`
 */
export type UserSelect = Prisma.UserSelect

/**
 * @deprecated Renamed to \`Prisma.UserInclude\`
 */
export type UserInclude = Prisma.UserInclude

/**
 * @deprecated Renamed to \`Prisma.FindUniqueUserArgs\`
 */
export type FindUniqueUserArgs = Prisma.FindUniqueUserArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstUserArgs\`
 */
export type FindFirstUserArgs = Prisma.FindFirstUserArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyUserArgs\`
 */
export type FindManyUserArgs = Prisma.FindManyUserArgs

/**
 * @deprecated Renamed to \`Prisma.UserCreateArgs\`
 */
export type UserCreateArgs = Prisma.UserCreateArgs

/**
 * @deprecated Renamed to \`Prisma.UserUpdateArgs\`
 */
export type UserUpdateArgs = Prisma.UserUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.UserUpdateManyArgs\`
 */
export type UserUpdateManyArgs = Prisma.UserUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.UserUpsertArgs\`
 */
export type UserUpsertArgs = Prisma.UserUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.UserDeleteArgs\`
 */
export type UserDeleteArgs = Prisma.UserDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.UserDeleteManyArgs\`
 */
export type UserDeleteManyArgs = Prisma.UserDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateM\`
 */
export type AggregateM = Prisma.AggregateM

/**
 * @deprecated Renamed to \`Prisma.MAvgAggregateOutputType\`
 */
export type MAvgAggregateOutputType = Prisma.MAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.MSumAggregateOutputType\`
 */
export type MSumAggregateOutputType = Prisma.MSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.MMinAggregateOutputType\`
 */
export type MMinAggregateOutputType = Prisma.MMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.MMaxAggregateOutputType\`
 */
export type MMaxAggregateOutputType = Prisma.MMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.MCountAggregateOutputType\`
 */
export type MCountAggregateOutputType = Prisma.MCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateMArgs\`
 */
export type AggregateMArgs = Prisma.AggregateMArgs

/**
 * @deprecated Renamed to \`Prisma.MAvgAggregateInputType\`
 */
export type MAvgAggregateInputType = Prisma.MAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.MSumAggregateInputType\`
 */
export type MSumAggregateInputType = Prisma.MSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.MMinAggregateInputType\`
 */
export type MMinAggregateInputType = Prisma.MMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.MMaxAggregateInputType\`
 */
export type MMaxAggregateInputType = Prisma.MMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.MCountAggregateInputType\`
 */
export type MCountAggregateInputType = Prisma.MCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.MSelect\`
 */
export type MSelect = Prisma.MSelect

/**
 * @deprecated Renamed to \`Prisma.MInclude\`
 */
export type MInclude = Prisma.MInclude

/**
 * @deprecated Renamed to \`Prisma.FindUniqueMArgs\`
 */
export type FindUniqueMArgs = Prisma.FindUniqueMArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstMArgs\`
 */
export type FindFirstMArgs = Prisma.FindFirstMArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyMArgs\`
 */
export type FindManyMArgs = Prisma.FindManyMArgs

/**
 * @deprecated Renamed to \`Prisma.MCreateArgs\`
 */
export type MCreateArgs = Prisma.MCreateArgs

/**
 * @deprecated Renamed to \`Prisma.MUpdateArgs\`
 */
export type MUpdateArgs = Prisma.MUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.MUpdateManyArgs\`
 */
export type MUpdateManyArgs = Prisma.MUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.MUpsertArgs\`
 */
export type MUpsertArgs = Prisma.MUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.MDeleteArgs\`
 */
export type MDeleteArgs = Prisma.MDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.MDeleteManyArgs\`
 */
export type MDeleteManyArgs = Prisma.MDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateN\`
 */
export type AggregateN = Prisma.AggregateN

/**
 * @deprecated Renamed to \`Prisma.NAvgAggregateOutputType\`
 */
export type NAvgAggregateOutputType = Prisma.NAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.NSumAggregateOutputType\`
 */
export type NSumAggregateOutputType = Prisma.NSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.NMinAggregateOutputType\`
 */
export type NMinAggregateOutputType = Prisma.NMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.NMaxAggregateOutputType\`
 */
export type NMaxAggregateOutputType = Prisma.NMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.NCountAggregateOutputType\`
 */
export type NCountAggregateOutputType = Prisma.NCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateNArgs\`
 */
export type AggregateNArgs = Prisma.AggregateNArgs

/**
 * @deprecated Renamed to \`Prisma.NAvgAggregateInputType\`
 */
export type NAvgAggregateInputType = Prisma.NAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.NSumAggregateInputType\`
 */
export type NSumAggregateInputType = Prisma.NSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.NMinAggregateInputType\`
 */
export type NMinAggregateInputType = Prisma.NMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.NMaxAggregateInputType\`
 */
export type NMaxAggregateInputType = Prisma.NMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.NCountAggregateInputType\`
 */
export type NCountAggregateInputType = Prisma.NCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.NSelect\`
 */
export type NSelect = Prisma.NSelect

/**
 * @deprecated Renamed to \`Prisma.NInclude\`
 */
export type NInclude = Prisma.NInclude

/**
 * @deprecated Renamed to \`Prisma.FindUniqueNArgs\`
 */
export type FindUniqueNArgs = Prisma.FindUniqueNArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstNArgs\`
 */
export type FindFirstNArgs = Prisma.FindFirstNArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyNArgs\`
 */
export type FindManyNArgs = Prisma.FindManyNArgs

/**
 * @deprecated Renamed to \`Prisma.NCreateArgs\`
 */
export type NCreateArgs = Prisma.NCreateArgs

/**
 * @deprecated Renamed to \`Prisma.NUpdateArgs\`
 */
export type NUpdateArgs = Prisma.NUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.NUpdateManyArgs\`
 */
export type NUpdateManyArgs = Prisma.NUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.NUpsertArgs\`
 */
export type NUpsertArgs = Prisma.NUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.NDeleteArgs\`
 */
export type NDeleteArgs = Prisma.NDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.NDeleteManyArgs\`
 */
export type NDeleteManyArgs = Prisma.NDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateOneOptional\`
 */
export type AggregateOneOptional = Prisma.AggregateOneOptional

/**
 * @deprecated Renamed to \`Prisma.OneOptionalAvgAggregateOutputType\`
 */
export type OneOptionalAvgAggregateOutputType = Prisma.OneOptionalAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalSumAggregateOutputType\`
 */
export type OneOptionalSumAggregateOutputType = Prisma.OneOptionalSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalMinAggregateOutputType\`
 */
export type OneOptionalMinAggregateOutputType = Prisma.OneOptionalMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalMaxAggregateOutputType\`
 */
export type OneOptionalMaxAggregateOutputType = Prisma.OneOptionalMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCountAggregateOutputType\`
 */
export type OneOptionalCountAggregateOutputType = Prisma.OneOptionalCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateOneOptionalArgs\`
 */
export type AggregateOneOptionalArgs = Prisma.AggregateOneOptionalArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalAvgAggregateInputType\`
 */
export type OneOptionalAvgAggregateInputType = Prisma.OneOptionalAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalSumAggregateInputType\`
 */
export type OneOptionalSumAggregateInputType = Prisma.OneOptionalSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalMinAggregateInputType\`
 */
export type OneOptionalMinAggregateInputType = Prisma.OneOptionalMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalMaxAggregateInputType\`
 */
export type OneOptionalMaxAggregateInputType = Prisma.OneOptionalMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCountAggregateInputType\`
 */
export type OneOptionalCountAggregateInputType = Prisma.OneOptionalCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OneOptionalSelect\`
 */
export type OneOptionalSelect = Prisma.OneOptionalSelect

/**
 * @deprecated Renamed to \`Prisma.OneOptionalInclude\`
 */
export type OneOptionalInclude = Prisma.OneOptionalInclude

/**
 * @deprecated Renamed to \`Prisma.FindUniqueOneOptionalArgs\`
 */
export type FindUniqueOneOptionalArgs = Prisma.FindUniqueOneOptionalArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstOneOptionalArgs\`
 */
export type FindFirstOneOptionalArgs = Prisma.FindFirstOneOptionalArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyOneOptionalArgs\`
 */
export type FindManyOneOptionalArgs = Prisma.FindManyOneOptionalArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCreateArgs\`
 */
export type OneOptionalCreateArgs = Prisma.OneOptionalCreateArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpdateArgs\`
 */
export type OneOptionalUpdateArgs = Prisma.OneOptionalUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpdateManyArgs\`
 */
export type OneOptionalUpdateManyArgs = Prisma.OneOptionalUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpsertArgs\`
 */
export type OneOptionalUpsertArgs = Prisma.OneOptionalUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalDeleteArgs\`
 */
export type OneOptionalDeleteArgs = Prisma.OneOptionalDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.OneOptionalDeleteManyArgs\`
 */
export type OneOptionalDeleteManyArgs = Prisma.OneOptionalDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateManyRequired\`
 */
export type AggregateManyRequired = Prisma.AggregateManyRequired

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredAvgAggregateOutputType\`
 */
export type ManyRequiredAvgAggregateOutputType = Prisma.ManyRequiredAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredSumAggregateOutputType\`
 */
export type ManyRequiredSumAggregateOutputType = Prisma.ManyRequiredSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredMinAggregateOutputType\`
 */
export type ManyRequiredMinAggregateOutputType = Prisma.ManyRequiredMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredMaxAggregateOutputType\`
 */
export type ManyRequiredMaxAggregateOutputType = Prisma.ManyRequiredMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCountAggregateOutputType\`
 */
export type ManyRequiredCountAggregateOutputType = Prisma.ManyRequiredCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateManyRequiredArgs\`
 */
export type AggregateManyRequiredArgs = Prisma.AggregateManyRequiredArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredAvgAggregateInputType\`
 */
export type ManyRequiredAvgAggregateInputType = Prisma.ManyRequiredAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredSumAggregateInputType\`
 */
export type ManyRequiredSumAggregateInputType = Prisma.ManyRequiredSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredMinAggregateInputType\`
 */
export type ManyRequiredMinAggregateInputType = Prisma.ManyRequiredMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredMaxAggregateInputType\`
 */
export type ManyRequiredMaxAggregateInputType = Prisma.ManyRequiredMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCountAggregateInputType\`
 */
export type ManyRequiredCountAggregateInputType = Prisma.ManyRequiredCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredSelect\`
 */
export type ManyRequiredSelect = Prisma.ManyRequiredSelect

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredInclude\`
 */
export type ManyRequiredInclude = Prisma.ManyRequiredInclude

/**
 * @deprecated Renamed to \`Prisma.FindUniqueManyRequiredArgs\`
 */
export type FindUniqueManyRequiredArgs = Prisma.FindUniqueManyRequiredArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstManyRequiredArgs\`
 */
export type FindFirstManyRequiredArgs = Prisma.FindFirstManyRequiredArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyManyRequiredArgs\`
 */
export type FindManyManyRequiredArgs = Prisma.FindManyManyRequiredArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCreateArgs\`
 */
export type ManyRequiredCreateArgs = Prisma.ManyRequiredCreateArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateArgs\`
 */
export type ManyRequiredUpdateArgs = Prisma.ManyRequiredUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateManyArgs\`
 */
export type ManyRequiredUpdateManyArgs = Prisma.ManyRequiredUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpsertArgs\`
 */
export type ManyRequiredUpsertArgs = Prisma.ManyRequiredUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredDeleteArgs\`
 */
export type ManyRequiredDeleteArgs = Prisma.ManyRequiredDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredDeleteManyArgs\`
 */
export type ManyRequiredDeleteManyArgs = Prisma.ManyRequiredDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateOptionalSide1\`
 */
export type AggregateOptionalSide1 = Prisma.AggregateOptionalSide1

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1AvgAggregateOutputType\`
 */
export type OptionalSide1AvgAggregateOutputType = Prisma.OptionalSide1AvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1SumAggregateOutputType\`
 */
export type OptionalSide1SumAggregateOutputType = Prisma.OptionalSide1SumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1MinAggregateOutputType\`
 */
export type OptionalSide1MinAggregateOutputType = Prisma.OptionalSide1MinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1MaxAggregateOutputType\`
 */
export type OptionalSide1MaxAggregateOutputType = Prisma.OptionalSide1MaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CountAggregateOutputType\`
 */
export type OptionalSide1CountAggregateOutputType = Prisma.OptionalSide1CountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateOptionalSide1Args\`
 */
export type AggregateOptionalSide1Args = Prisma.AggregateOptionalSide1Args

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1AvgAggregateInputType\`
 */
export type OptionalSide1AvgAggregateInputType = Prisma.OptionalSide1AvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1SumAggregateInputType\`
 */
export type OptionalSide1SumAggregateInputType = Prisma.OptionalSide1SumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1MinAggregateInputType\`
 */
export type OptionalSide1MinAggregateInputType = Prisma.OptionalSide1MinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1MaxAggregateInputType\`
 */
export type OptionalSide1MaxAggregateInputType = Prisma.OptionalSide1MaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CountAggregateInputType\`
 */
export type OptionalSide1CountAggregateInputType = Prisma.OptionalSide1CountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1Select\`
 */
export type OptionalSide1Select = Prisma.OptionalSide1Select

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1Include\`
 */
export type OptionalSide1Include = Prisma.OptionalSide1Include

/**
 * @deprecated Renamed to \`Prisma.FindUniqueOptionalSide1Args\`
 */
export type FindUniqueOptionalSide1Args = Prisma.FindUniqueOptionalSide1Args

/**
 * @deprecated Renamed to \`Prisma.FindFirstOptionalSide1Args\`
 */
export type FindFirstOptionalSide1Args = Prisma.FindFirstOptionalSide1Args

/**
 * @deprecated Renamed to \`Prisma.FindManyOptionalSide1Args\`
 */
export type FindManyOptionalSide1Args = Prisma.FindManyOptionalSide1Args

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CreateArgs\`
 */
export type OptionalSide1CreateArgs = Prisma.OptionalSide1CreateArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpdateArgs\`
 */
export type OptionalSide1UpdateArgs = Prisma.OptionalSide1UpdateArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpdateManyArgs\`
 */
export type OptionalSide1UpdateManyArgs = Prisma.OptionalSide1UpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpsertArgs\`
 */
export type OptionalSide1UpsertArgs = Prisma.OptionalSide1UpsertArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1DeleteArgs\`
 */
export type OptionalSide1DeleteArgs = Prisma.OptionalSide1DeleteArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1DeleteManyArgs\`
 */
export type OptionalSide1DeleteManyArgs = Prisma.OptionalSide1DeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateOptionalSide2\`
 */
export type AggregateOptionalSide2 = Prisma.AggregateOptionalSide2

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2AvgAggregateOutputType\`
 */
export type OptionalSide2AvgAggregateOutputType = Prisma.OptionalSide2AvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2SumAggregateOutputType\`
 */
export type OptionalSide2SumAggregateOutputType = Prisma.OptionalSide2SumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2MinAggregateOutputType\`
 */
export type OptionalSide2MinAggregateOutputType = Prisma.OptionalSide2MinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2MaxAggregateOutputType\`
 */
export type OptionalSide2MaxAggregateOutputType = Prisma.OptionalSide2MaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CountAggregateOutputType\`
 */
export type OptionalSide2CountAggregateOutputType = Prisma.OptionalSide2CountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateOptionalSide2Args\`
 */
export type AggregateOptionalSide2Args = Prisma.AggregateOptionalSide2Args

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2AvgAggregateInputType\`
 */
export type OptionalSide2AvgAggregateInputType = Prisma.OptionalSide2AvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2SumAggregateInputType\`
 */
export type OptionalSide2SumAggregateInputType = Prisma.OptionalSide2SumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2MinAggregateInputType\`
 */
export type OptionalSide2MinAggregateInputType = Prisma.OptionalSide2MinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2MaxAggregateInputType\`
 */
export type OptionalSide2MaxAggregateInputType = Prisma.OptionalSide2MaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CountAggregateInputType\`
 */
export type OptionalSide2CountAggregateInputType = Prisma.OptionalSide2CountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2Select\`
 */
export type OptionalSide2Select = Prisma.OptionalSide2Select

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2Include\`
 */
export type OptionalSide2Include = Prisma.OptionalSide2Include

/**
 * @deprecated Renamed to \`Prisma.FindUniqueOptionalSide2Args\`
 */
export type FindUniqueOptionalSide2Args = Prisma.FindUniqueOptionalSide2Args

/**
 * @deprecated Renamed to \`Prisma.FindFirstOptionalSide2Args\`
 */
export type FindFirstOptionalSide2Args = Prisma.FindFirstOptionalSide2Args

/**
 * @deprecated Renamed to \`Prisma.FindManyOptionalSide2Args\`
 */
export type FindManyOptionalSide2Args = Prisma.FindManyOptionalSide2Args

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CreateArgs\`
 */
export type OptionalSide2CreateArgs = Prisma.OptionalSide2CreateArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpdateArgs\`
 */
export type OptionalSide2UpdateArgs = Prisma.OptionalSide2UpdateArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpdateManyArgs\`
 */
export type OptionalSide2UpdateManyArgs = Prisma.OptionalSide2UpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpsertArgs\`
 */
export type OptionalSide2UpsertArgs = Prisma.OptionalSide2UpsertArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2DeleteArgs\`
 */
export type OptionalSide2DeleteArgs = Prisma.OptionalSide2DeleteArgs

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2DeleteManyArgs\`
 */
export type OptionalSide2DeleteManyArgs = Prisma.OptionalSide2DeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateA\`
 */
export type AggregateA = Prisma.AggregateA

/**
 * @deprecated Renamed to \`Prisma.AAvgAggregateOutputType\`
 */
export type AAvgAggregateOutputType = Prisma.AAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ASumAggregateOutputType\`
 */
export type ASumAggregateOutputType = Prisma.ASumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AMinAggregateOutputType\`
 */
export type AMinAggregateOutputType = Prisma.AMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AMaxAggregateOutputType\`
 */
export type AMaxAggregateOutputType = Prisma.AMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ACountAggregateOutputType\`
 */
export type ACountAggregateOutputType = Prisma.ACountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateAArgs\`
 */
export type AggregateAArgs = Prisma.AggregateAArgs

/**
 * @deprecated Renamed to \`Prisma.AAvgAggregateInputType\`
 */
export type AAvgAggregateInputType = Prisma.AAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ASumAggregateInputType\`
 */
export type ASumAggregateInputType = Prisma.ASumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.AMinAggregateInputType\`
 */
export type AMinAggregateInputType = Prisma.AMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.AMaxAggregateInputType\`
 */
export type AMaxAggregateInputType = Prisma.AMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ACountAggregateInputType\`
 */
export type ACountAggregateInputType = Prisma.ACountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ASelect\`
 */
export type ASelect = Prisma.ASelect

/**
 * @deprecated Renamed to \`Prisma.FindUniqueAArgs\`
 */
export type FindUniqueAArgs = Prisma.FindUniqueAArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstAArgs\`
 */
export type FindFirstAArgs = Prisma.FindFirstAArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyAArgs\`
 */
export type FindManyAArgs = Prisma.FindManyAArgs

/**
 * @deprecated Renamed to \`Prisma.ACreateArgs\`
 */
export type ACreateArgs = Prisma.ACreateArgs

/**
 * @deprecated Renamed to \`Prisma.AUpdateArgs\`
 */
export type AUpdateArgs = Prisma.AUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.AUpdateManyArgs\`
 */
export type AUpdateManyArgs = Prisma.AUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.AUpsertArgs\`
 */
export type AUpsertArgs = Prisma.AUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.ADeleteArgs\`
 */
export type ADeleteArgs = Prisma.ADeleteArgs

/**
 * @deprecated Renamed to \`Prisma.ADeleteManyArgs\`
 */
export type ADeleteManyArgs = Prisma.ADeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateB\`
 */
export type AggregateB = Prisma.AggregateB

/**
 * @deprecated Renamed to \`Prisma.BAvgAggregateOutputType\`
 */
export type BAvgAggregateOutputType = Prisma.BAvgAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.BSumAggregateOutputType\`
 */
export type BSumAggregateOutputType = Prisma.BSumAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.BMinAggregateOutputType\`
 */
export type BMinAggregateOutputType = Prisma.BMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.BMaxAggregateOutputType\`
 */
export type BMaxAggregateOutputType = Prisma.BMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.BCountAggregateOutputType\`
 */
export type BCountAggregateOutputType = Prisma.BCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateBArgs\`
 */
export type AggregateBArgs = Prisma.AggregateBArgs

/**
 * @deprecated Renamed to \`Prisma.BAvgAggregateInputType\`
 */
export type BAvgAggregateInputType = Prisma.BAvgAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.BSumAggregateInputType\`
 */
export type BSumAggregateInputType = Prisma.BSumAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.BMinAggregateInputType\`
 */
export type BMinAggregateInputType = Prisma.BMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.BMaxAggregateInputType\`
 */
export type BMaxAggregateInputType = Prisma.BMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.BCountAggregateInputType\`
 */
export type BCountAggregateInputType = Prisma.BCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.BSelect\`
 */
export type BSelect = Prisma.BSelect

/**
 * @deprecated Renamed to \`Prisma.FindUniqueBArgs\`
 */
export type FindUniqueBArgs = Prisma.FindUniqueBArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstBArgs\`
 */
export type FindFirstBArgs = Prisma.FindFirstBArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyBArgs\`
 */
export type FindManyBArgs = Prisma.FindManyBArgs

/**
 * @deprecated Renamed to \`Prisma.BCreateArgs\`
 */
export type BCreateArgs = Prisma.BCreateArgs

/**
 * @deprecated Renamed to \`Prisma.BUpdateArgs\`
 */
export type BUpdateArgs = Prisma.BUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.BUpdateManyArgs\`
 */
export type BUpdateManyArgs = Prisma.BUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.BUpsertArgs\`
 */
export type BUpsertArgs = Prisma.BUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.BDeleteArgs\`
 */
export type BDeleteArgs = Prisma.BDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.BDeleteManyArgs\`
 */
export type BDeleteManyArgs = Prisma.BDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateC\`
 */
export type AggregateC = Prisma.AggregateC

/**
 * @deprecated Renamed to \`Prisma.CMinAggregateOutputType\`
 */
export type CMinAggregateOutputType = Prisma.CMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.CMaxAggregateOutputType\`
 */
export type CMaxAggregateOutputType = Prisma.CMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.CCountAggregateOutputType\`
 */
export type CCountAggregateOutputType = Prisma.CCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateCArgs\`
 */
export type AggregateCArgs = Prisma.AggregateCArgs

/**
 * @deprecated Renamed to \`Prisma.CMinAggregateInputType\`
 */
export type CMinAggregateInputType = Prisma.CMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.CMaxAggregateInputType\`
 */
export type CMaxAggregateInputType = Prisma.CMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.CCountAggregateInputType\`
 */
export type CCountAggregateInputType = Prisma.CCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.CSelect\`
 */
export type CSelect = Prisma.CSelect

/**
 * @deprecated Renamed to \`Prisma.FindUniqueCArgs\`
 */
export type FindUniqueCArgs = Prisma.FindUniqueCArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstCArgs\`
 */
export type FindFirstCArgs = Prisma.FindFirstCArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyCArgs\`
 */
export type FindManyCArgs = Prisma.FindManyCArgs

/**
 * @deprecated Renamed to \`Prisma.CCreateArgs\`
 */
export type CCreateArgs = Prisma.CCreateArgs

/**
 * @deprecated Renamed to \`Prisma.CUpdateArgs\`
 */
export type CUpdateArgs = Prisma.CUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.CUpdateManyArgs\`
 */
export type CUpdateManyArgs = Prisma.CUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.CUpsertArgs\`
 */
export type CUpsertArgs = Prisma.CUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.CDeleteArgs\`
 */
export type CDeleteArgs = Prisma.CDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.CDeleteManyArgs\`
 */
export type CDeleteManyArgs = Prisma.CDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateD\`
 */
export type AggregateD = Prisma.AggregateD

/**
 * @deprecated Renamed to \`Prisma.DMinAggregateOutputType\`
 */
export type DMinAggregateOutputType = Prisma.DMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.DMaxAggregateOutputType\`
 */
export type DMaxAggregateOutputType = Prisma.DMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.DCountAggregateOutputType\`
 */
export type DCountAggregateOutputType = Prisma.DCountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateDArgs\`
 */
export type AggregateDArgs = Prisma.AggregateDArgs

/**
 * @deprecated Renamed to \`Prisma.DMinAggregateInputType\`
 */
export type DMinAggregateInputType = Prisma.DMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.DMaxAggregateInputType\`
 */
export type DMaxAggregateInputType = Prisma.DMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.DCountAggregateInputType\`
 */
export type DCountAggregateInputType = Prisma.DCountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.DSelect\`
 */
export type DSelect = Prisma.DSelect

/**
 * @deprecated Renamed to \`Prisma.FindUniqueDArgs\`
 */
export type FindUniqueDArgs = Prisma.FindUniqueDArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstDArgs\`
 */
export type FindFirstDArgs = Prisma.FindFirstDArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyDArgs\`
 */
export type FindManyDArgs = Prisma.FindManyDArgs

/**
 * @deprecated Renamed to \`Prisma.DCreateArgs\`
 */
export type DCreateArgs = Prisma.DCreateArgs

/**
 * @deprecated Renamed to \`Prisma.DUpdateArgs\`
 */
export type DUpdateArgs = Prisma.DUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.DUpdateManyArgs\`
 */
export type DUpdateManyArgs = Prisma.DUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.DUpsertArgs\`
 */
export type DUpsertArgs = Prisma.DUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.DDeleteArgs\`
 */
export type DDeleteArgs = Prisma.DDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.DDeleteManyArgs\`
 */
export type DDeleteManyArgs = Prisma.DDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.AggregateE\`
 */
export type AggregateE = Prisma.AggregateE

/**
 * @deprecated Renamed to \`Prisma.EMinAggregateOutputType\`
 */
export type EMinAggregateOutputType = Prisma.EMinAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.EMaxAggregateOutputType\`
 */
export type EMaxAggregateOutputType = Prisma.EMaxAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.ECountAggregateOutputType\`
 */
export type ECountAggregateOutputType = Prisma.ECountAggregateOutputType

/**
 * @deprecated Renamed to \`Prisma.AggregateEArgs\`
 */
export type AggregateEArgs = Prisma.AggregateEArgs

/**
 * @deprecated Renamed to \`Prisma.EMinAggregateInputType\`
 */
export type EMinAggregateInputType = Prisma.EMinAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.EMaxAggregateInputType\`
 */
export type EMaxAggregateInputType = Prisma.EMaxAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ECountAggregateInputType\`
 */
export type ECountAggregateInputType = Prisma.ECountAggregateInputType

/**
 * @deprecated Renamed to \`Prisma.ESelect\`
 */
export type ESelect = Prisma.ESelect

/**
 * @deprecated Renamed to \`Prisma.FindUniqueEArgs\`
 */
export type FindUniqueEArgs = Prisma.FindUniqueEArgs

/**
 * @deprecated Renamed to \`Prisma.FindFirstEArgs\`
 */
export type FindFirstEArgs = Prisma.FindFirstEArgs

/**
 * @deprecated Renamed to \`Prisma.FindManyEArgs\`
 */
export type FindManyEArgs = Prisma.FindManyEArgs

/**
 * @deprecated Renamed to \`Prisma.ECreateArgs\`
 */
export type ECreateArgs = Prisma.ECreateArgs

/**
 * @deprecated Renamed to \`Prisma.EUpdateArgs\`
 */
export type EUpdateArgs = Prisma.EUpdateArgs

/**
 * @deprecated Renamed to \`Prisma.EUpdateManyArgs\`
 */
export type EUpdateManyArgs = Prisma.EUpdateManyArgs

/**
 * @deprecated Renamed to \`Prisma.EUpsertArgs\`
 */
export type EUpsertArgs = Prisma.EUpsertArgs

/**
 * @deprecated Renamed to \`Prisma.EDeleteArgs\`
 */
export type EDeleteArgs = Prisma.EDeleteArgs

/**
 * @deprecated Renamed to \`Prisma.EDeleteManyArgs\`
 */
export type EDeleteManyArgs = Prisma.EDeleteManyArgs

/**
 * @deprecated Renamed to \`Prisma.PostWhereInput\`
 */
export type PostWhereInput = Prisma.PostWhereInput

/**
 * @deprecated Renamed to \`Prisma.PostOrderByInput\`
 */
export type PostOrderByInput = Prisma.PostOrderByInput

/**
 * @deprecated Renamed to \`Prisma.PostWhereUniqueInput\`
 */
export type PostWhereUniqueInput = Prisma.PostWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.UserWhereInput\`
 */
export type UserWhereInput = Prisma.UserWhereInput

/**
 * @deprecated Renamed to \`Prisma.UserOrderByInput\`
 */
export type UserOrderByInput = Prisma.UserOrderByInput

/**
 * @deprecated Renamed to \`Prisma.UserWhereUniqueInput\`
 */
export type UserWhereUniqueInput = Prisma.UserWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.MWhereInput\`
 */
export type MWhereInput = Prisma.MWhereInput

/**
 * @deprecated Renamed to \`Prisma.MOrderByInput\`
 */
export type MOrderByInput = Prisma.MOrderByInput

/**
 * @deprecated Renamed to \`Prisma.MWhereUniqueInput\`
 */
export type MWhereUniqueInput = Prisma.MWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.NWhereInput\`
 */
export type NWhereInput = Prisma.NWhereInput

/**
 * @deprecated Renamed to \`Prisma.NOrderByInput\`
 */
export type NOrderByInput = Prisma.NOrderByInput

/**
 * @deprecated Renamed to \`Prisma.NWhereUniqueInput\`
 */
export type NWhereUniqueInput = Prisma.NWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalWhereInput\`
 */
export type OneOptionalWhereInput = Prisma.OneOptionalWhereInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalOrderByInput\`
 */
export type OneOptionalOrderByInput = Prisma.OneOptionalOrderByInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalWhereUniqueInput\`
 */
export type OneOptionalWhereUniqueInput = Prisma.OneOptionalWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredWhereInput\`
 */
export type ManyRequiredWhereInput = Prisma.ManyRequiredWhereInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredOrderByInput\`
 */
export type ManyRequiredOrderByInput = Prisma.ManyRequiredOrderByInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredWhereUniqueInput\`
 */
export type ManyRequiredWhereUniqueInput = Prisma.ManyRequiredWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1WhereInput\`
 */
export type OptionalSide1WhereInput = Prisma.OptionalSide1WhereInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1OrderByInput\`
 */
export type OptionalSide1OrderByInput = Prisma.OptionalSide1OrderByInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1WhereUniqueInput\`
 */
export type OptionalSide1WhereUniqueInput = Prisma.OptionalSide1WhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2WhereInput\`
 */
export type OptionalSide2WhereInput = Prisma.OptionalSide2WhereInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2OrderByInput\`
 */
export type OptionalSide2OrderByInput = Prisma.OptionalSide2OrderByInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2WhereUniqueInput\`
 */
export type OptionalSide2WhereUniqueInput = Prisma.OptionalSide2WhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.AWhereInput\`
 */
export type AWhereInput = Prisma.AWhereInput

/**
 * @deprecated Renamed to \`Prisma.AOrderByInput\`
 */
export type AOrderByInput = Prisma.AOrderByInput

/**
 * @deprecated Renamed to \`Prisma.AWhereUniqueInput\`
 */
export type AWhereUniqueInput = Prisma.AWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.BWhereInput\`
 */
export type BWhereInput = Prisma.BWhereInput

/**
 * @deprecated Renamed to \`Prisma.BOrderByInput\`
 */
export type BOrderByInput = Prisma.BOrderByInput

/**
 * @deprecated Renamed to \`Prisma.BWhereUniqueInput\`
 */
export type BWhereUniqueInput = Prisma.BWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.CWhereInput\`
 */
export type CWhereInput = Prisma.CWhereInput

/**
 * @deprecated Renamed to \`Prisma.COrderByInput\`
 */
export type COrderByInput = Prisma.COrderByInput

/**
 * @deprecated Renamed to \`Prisma.CWhereUniqueInput\`
 */
export type CWhereUniqueInput = Prisma.CWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.DWhereInput\`
 */
export type DWhereInput = Prisma.DWhereInput

/**
 * @deprecated Renamed to \`Prisma.DOrderByInput\`
 */
export type DOrderByInput = Prisma.DOrderByInput

/**
 * @deprecated Renamed to \`Prisma.DWhereUniqueInput\`
 */
export type DWhereUniqueInput = Prisma.DWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.EWhereInput\`
 */
export type EWhereInput = Prisma.EWhereInput

/**
 * @deprecated Renamed to \`Prisma.EOrderByInput\`
 */
export type EOrderByInput = Prisma.EOrderByInput

/**
 * @deprecated Renamed to \`Prisma.EWhereUniqueInput\`
 */
export type EWhereUniqueInput = Prisma.EWhereUniqueInput

/**
 * @deprecated Renamed to \`Prisma.PostCreateInput\`
 */
export type PostCreateInput = Prisma.PostCreateInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedCreateInput\`
 */
export type PostUncheckedCreateInput = Prisma.PostUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.PostUpdateInput\`
 */
export type PostUpdateInput = Prisma.PostUpdateInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedUpdateInput\`
 */
export type PostUncheckedUpdateInput = Prisma.PostUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.PostUpdateManyMutationInput\`
 */
export type PostUpdateManyMutationInput = Prisma.PostUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedUpdateManyInput\`
 */
export type PostUncheckedUpdateManyInput = Prisma.PostUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.UserCreateInput\`
 */
export type UserCreateInput = Prisma.UserCreateInput

/**
 * @deprecated Renamed to \`Prisma.UserUncheckedCreateInput\`
 */
export type UserUncheckedCreateInput = Prisma.UserUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.UserUpdateInput\`
 */
export type UserUpdateInput = Prisma.UserUpdateInput

/**
 * @deprecated Renamed to \`Prisma.UserUncheckedUpdateInput\`
 */
export type UserUncheckedUpdateInput = Prisma.UserUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.UserUpdateManyMutationInput\`
 */
export type UserUpdateManyMutationInput = Prisma.UserUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.UserUncheckedUpdateManyInput\`
 */
export type UserUncheckedUpdateManyInput = Prisma.UserUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.MCreateInput\`
 */
export type MCreateInput = Prisma.MCreateInput

/**
 * @deprecated Renamed to \`Prisma.MUncheckedCreateInput\`
 */
export type MUncheckedCreateInput = Prisma.MUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.MUpdateInput\`
 */
export type MUpdateInput = Prisma.MUpdateInput

/**
 * @deprecated Renamed to \`Prisma.MUncheckedUpdateInput\`
 */
export type MUncheckedUpdateInput = Prisma.MUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.MUpdateManyMutationInput\`
 */
export type MUpdateManyMutationInput = Prisma.MUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.MUncheckedUpdateManyInput\`
 */
export type MUncheckedUpdateManyInput = Prisma.MUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.NCreateInput\`
 */
export type NCreateInput = Prisma.NCreateInput

/**
 * @deprecated Renamed to \`Prisma.NUncheckedCreateInput\`
 */
export type NUncheckedCreateInput = Prisma.NUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.NUpdateInput\`
 */
export type NUpdateInput = Prisma.NUpdateInput

/**
 * @deprecated Renamed to \`Prisma.NUncheckedUpdateInput\`
 */
export type NUncheckedUpdateInput = Prisma.NUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.NUpdateManyMutationInput\`
 */
export type NUpdateManyMutationInput = Prisma.NUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.NUncheckedUpdateManyInput\`
 */
export type NUncheckedUpdateManyInput = Prisma.NUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCreateInput\`
 */
export type OneOptionalCreateInput = Prisma.OneOptionalCreateInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUncheckedCreateInput\`
 */
export type OneOptionalUncheckedCreateInput = Prisma.OneOptionalUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpdateInput\`
 */
export type OneOptionalUpdateInput = Prisma.OneOptionalUpdateInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUncheckedUpdateInput\`
 */
export type OneOptionalUncheckedUpdateInput = Prisma.OneOptionalUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpdateManyMutationInput\`
 */
export type OneOptionalUpdateManyMutationInput = Prisma.OneOptionalUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUncheckedUpdateManyInput\`
 */
export type OneOptionalUncheckedUpdateManyInput = Prisma.OneOptionalUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCreateInput\`
 */
export type ManyRequiredCreateInput = Prisma.ManyRequiredCreateInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedCreateInput\`
 */
export type ManyRequiredUncheckedCreateInput = Prisma.ManyRequiredUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateInput\`
 */
export type ManyRequiredUpdateInput = Prisma.ManyRequiredUpdateInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedUpdateInput\`
 */
export type ManyRequiredUncheckedUpdateInput = Prisma.ManyRequiredUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateManyMutationInput\`
 */
export type ManyRequiredUpdateManyMutationInput = Prisma.ManyRequiredUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedUpdateManyInput\`
 */
export type ManyRequiredUncheckedUpdateManyInput = Prisma.ManyRequiredUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CreateInput\`
 */
export type OptionalSide1CreateInput = Prisma.OptionalSide1CreateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedCreateInput\`
 */
export type OptionalSide1UncheckedCreateInput = Prisma.OptionalSide1UncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpdateInput\`
 */
export type OptionalSide1UpdateInput = Prisma.OptionalSide1UpdateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedUpdateInput\`
 */
export type OptionalSide1UncheckedUpdateInput = Prisma.OptionalSide1UncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpdateManyMutationInput\`
 */
export type OptionalSide1UpdateManyMutationInput = Prisma.OptionalSide1UpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedUpdateManyInput\`
 */
export type OptionalSide1UncheckedUpdateManyInput = Prisma.OptionalSide1UncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CreateInput\`
 */
export type OptionalSide2CreateInput = Prisma.OptionalSide2CreateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UncheckedCreateInput\`
 */
export type OptionalSide2UncheckedCreateInput = Prisma.OptionalSide2UncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpdateInput\`
 */
export type OptionalSide2UpdateInput = Prisma.OptionalSide2UpdateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UncheckedUpdateInput\`
 */
export type OptionalSide2UncheckedUpdateInput = Prisma.OptionalSide2UncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpdateManyMutationInput\`
 */
export type OptionalSide2UpdateManyMutationInput = Prisma.OptionalSide2UpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UncheckedUpdateManyInput\`
 */
export type OptionalSide2UncheckedUpdateManyInput = Prisma.OptionalSide2UncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.ACreateInput\`
 */
export type ACreateInput = Prisma.ACreateInput

/**
 * @deprecated Renamed to \`Prisma.AUncheckedCreateInput\`
 */
export type AUncheckedCreateInput = Prisma.AUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.AUpdateInput\`
 */
export type AUpdateInput = Prisma.AUpdateInput

/**
 * @deprecated Renamed to \`Prisma.AUncheckedUpdateInput\`
 */
export type AUncheckedUpdateInput = Prisma.AUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.AUpdateManyMutationInput\`
 */
export type AUpdateManyMutationInput = Prisma.AUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.AUncheckedUpdateManyInput\`
 */
export type AUncheckedUpdateManyInput = Prisma.AUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.BCreateInput\`
 */
export type BCreateInput = Prisma.BCreateInput

/**
 * @deprecated Renamed to \`Prisma.BUncheckedCreateInput\`
 */
export type BUncheckedCreateInput = Prisma.BUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.BUpdateInput\`
 */
export type BUpdateInput = Prisma.BUpdateInput

/**
 * @deprecated Renamed to \`Prisma.BUncheckedUpdateInput\`
 */
export type BUncheckedUpdateInput = Prisma.BUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.BUpdateManyMutationInput\`
 */
export type BUpdateManyMutationInput = Prisma.BUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.BUncheckedUpdateManyInput\`
 */
export type BUncheckedUpdateManyInput = Prisma.BUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.CCreateInput\`
 */
export type CCreateInput = Prisma.CCreateInput

/**
 * @deprecated Renamed to \`Prisma.CUncheckedCreateInput\`
 */
export type CUncheckedCreateInput = Prisma.CUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.CUpdateInput\`
 */
export type CUpdateInput = Prisma.CUpdateInput

/**
 * @deprecated Renamed to \`Prisma.CUncheckedUpdateInput\`
 */
export type CUncheckedUpdateInput = Prisma.CUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.CUpdateManyMutationInput\`
 */
export type CUpdateManyMutationInput = Prisma.CUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.CUncheckedUpdateManyInput\`
 */
export type CUncheckedUpdateManyInput = Prisma.CUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.DCreateInput\`
 */
export type DCreateInput = Prisma.DCreateInput

/**
 * @deprecated Renamed to \`Prisma.DUncheckedCreateInput\`
 */
export type DUncheckedCreateInput = Prisma.DUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.DUpdateInput\`
 */
export type DUpdateInput = Prisma.DUpdateInput

/**
 * @deprecated Renamed to \`Prisma.DUncheckedUpdateInput\`
 */
export type DUncheckedUpdateInput = Prisma.DUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.DUpdateManyMutationInput\`
 */
export type DUpdateManyMutationInput = Prisma.DUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.DUncheckedUpdateManyInput\`
 */
export type DUncheckedUpdateManyInput = Prisma.DUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.ECreateInput\`
 */
export type ECreateInput = Prisma.ECreateInput

/**
 * @deprecated Renamed to \`Prisma.EUncheckedCreateInput\`
 */
export type EUncheckedCreateInput = Prisma.EUncheckedCreateInput

/**
 * @deprecated Renamed to \`Prisma.EUpdateInput\`
 */
export type EUpdateInput = Prisma.EUpdateInput

/**
 * @deprecated Renamed to \`Prisma.EUncheckedUpdateInput\`
 */
export type EUncheckedUpdateInput = Prisma.EUncheckedUpdateInput

/**
 * @deprecated Renamed to \`Prisma.EUpdateManyMutationInput\`
 */
export type EUpdateManyMutationInput = Prisma.EUpdateManyMutationInput

/**
 * @deprecated Renamed to \`Prisma.EUncheckedUpdateManyInput\`
 */
export type EUncheckedUpdateManyInput = Prisma.EUncheckedUpdateManyInput

/**
 * @deprecated Renamed to \`Prisma.IntFilter\`
 */
export type IntFilter = Prisma.IntFilter

/**
 * @deprecated Renamed to \`Prisma.DateTimeFilter\`
 */
export type DateTimeFilter = Prisma.DateTimeFilter

/**
 * @deprecated Renamed to \`Prisma.StringFilter\`
 */
export type StringFilter = Prisma.StringFilter

/**
 * @deprecated Renamed to \`Prisma.StringNullableFilter\`
 */
export type StringNullableFilter = Prisma.StringNullableFilter

/**
 * @deprecated Renamed to \`Prisma.BoolFilter\`
 */
export type BoolFilter = Prisma.BoolFilter

/**
 * @deprecated Renamed to \`Prisma.UserRelationFilter\`
 */
export type UserRelationFilter = Prisma.UserRelationFilter

/**
 * @deprecated Renamed to \`Prisma.IntNullableFilter\`
 */
export type IntNullableFilter = Prisma.IntNullableFilter

/**
 * @deprecated Renamed to \`Prisma.FloatFilter\`
 */
export type FloatFilter = Prisma.FloatFilter

/**
 * @deprecated Renamed to \`Prisma.FloatNullableFilter\`
 */
export type FloatNullableFilter = Prisma.FloatNullableFilter

/**
 * @deprecated Renamed to \`Prisma.JsonFilter\`
 */
export type JsonFilter = Prisma.JsonFilter

/**
 * @deprecated Renamed to \`Prisma.JsonNullableFilter\`
 */
export type JsonNullableFilter = Prisma.JsonNullableFilter

/**
 * @deprecated Renamed to \`Prisma.EnumABeautifulEnumFilter\`
 */
export type EnumABeautifulEnumFilter = Prisma.EnumABeautifulEnumFilter

/**
 * @deprecated Renamed to \`Prisma.EnumABeautifulEnumNullableFilter\`
 */
export type EnumABeautifulEnumNullableFilter = Prisma.EnumABeautifulEnumNullableFilter

/**
 * @deprecated Renamed to \`Prisma.BoolNullableFilter\`
 */
export type BoolNullableFilter = Prisma.BoolNullableFilter

/**
 * @deprecated Renamed to \`Prisma.PostListRelationFilter\`
 */
export type PostListRelationFilter = Prisma.PostListRelationFilter

/**
 * @deprecated Renamed to \`Prisma.NListRelationFilter\`
 */
export type NListRelationFilter = Prisma.NListRelationFilter

/**
 * @deprecated Renamed to \`Prisma.MListRelationFilter\`
 */
export type MListRelationFilter = Prisma.MListRelationFilter

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredListRelationFilter\`
 */
export type ManyRequiredListRelationFilter = Prisma.ManyRequiredListRelationFilter

/**
 * @deprecated Renamed to \`Prisma.OneOptionalRelationFilter\`
 */
export type OneOptionalRelationFilter = Prisma.OneOptionalRelationFilter

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2RelationFilter\`
 */
export type OptionalSide2RelationFilter = Prisma.OptionalSide2RelationFilter

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1RelationFilter\`
 */
export type OptionalSide1RelationFilter = Prisma.OptionalSide1RelationFilter

/**
 * @deprecated Renamed to \`Prisma.BigIntFilter\`
 */
export type BigIntFilter = Prisma.BigIntFilter

/**
 * @deprecated Renamed to \`Prisma.DecimalFilter\`
 */
export type DecimalFilter = Prisma.DecimalFilter

/**
 * @deprecated Renamed to \`Prisma.BytesFilter\`
 */
export type BytesFilter = Prisma.BytesFilter

/**
 * @deprecated Renamed to \`Prisma.UserCreateOneWithoutPostsInput\`
 */
export type UserCreateOneWithoutPostsInput = Prisma.UserCreateOneWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.DateTimeFieldUpdateOperationsInput\`
 */
export type DateTimeFieldUpdateOperationsInput = Prisma.DateTimeFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.StringFieldUpdateOperationsInput\`
 */
export type StringFieldUpdateOperationsInput = Prisma.StringFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.NullableStringFieldUpdateOperationsInput\`
 */
export type NullableStringFieldUpdateOperationsInput = Prisma.NullableStringFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.BoolFieldUpdateOperationsInput\`
 */
export type BoolFieldUpdateOperationsInput = Prisma.BoolFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.UserUpdateOneRequiredWithoutPostsInput\`
 */
export type UserUpdateOneRequiredWithoutPostsInput = Prisma.UserUpdateOneRequiredWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.IntFieldUpdateOperationsInput\`
 */
export type IntFieldUpdateOperationsInput = Prisma.IntFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.PostCreateManyWithoutAuthorInput\`
 */
export type PostCreateManyWithoutAuthorInput = Prisma.PostCreateManyWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedCreateManyWithoutAuthorInput\`
 */
export type PostUncheckedCreateManyWithoutAuthorInput = Prisma.PostUncheckedCreateManyWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.NullableIntFieldUpdateOperationsInput\`
 */
export type NullableIntFieldUpdateOperationsInput = Prisma.NullableIntFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.FloatFieldUpdateOperationsInput\`
 */
export type FloatFieldUpdateOperationsInput = Prisma.FloatFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.NullableFloatFieldUpdateOperationsInput\`
 */
export type NullableFloatFieldUpdateOperationsInput = Prisma.NullableFloatFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.EnumABeautifulEnumFieldUpdateOperationsInput\`
 */
export type EnumABeautifulEnumFieldUpdateOperationsInput = Prisma.EnumABeautifulEnumFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.NullableEnumABeautifulEnumFieldUpdateOperationsInput\`
 */
export type NullableEnumABeautifulEnumFieldUpdateOperationsInput = Prisma.NullableEnumABeautifulEnumFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.NullableBoolFieldUpdateOperationsInput\`
 */
export type NullableBoolFieldUpdateOperationsInput = Prisma.NullableBoolFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.PostUpdateManyWithoutAuthorInput\`
 */
export type PostUpdateManyWithoutAuthorInput = Prisma.PostUpdateManyWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedUpdateManyWithoutAuthorInput\`
 */
export type PostUncheckedUpdateManyWithoutAuthorInput = Prisma.PostUncheckedUpdateManyWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.NCreateManyWithoutMInput\`
 */
export type NCreateManyWithoutMInput = Prisma.NCreateManyWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NUpdateManyWithoutMInput\`
 */
export type NUpdateManyWithoutMInput = Prisma.NUpdateManyWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.MCreateManyWithoutNInput\`
 */
export type MCreateManyWithoutNInput = Prisma.MCreateManyWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MUpdateManyWithoutNInput\`
 */
export type MUpdateManyWithoutNInput = Prisma.MUpdateManyWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCreateManyWithoutOneInput\`
 */
export type ManyRequiredCreateManyWithoutOneInput = Prisma.ManyRequiredCreateManyWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedCreateManyWithoutOneInput\`
 */
export type ManyRequiredUncheckedCreateManyWithoutOneInput = Prisma.ManyRequiredUncheckedCreateManyWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateManyWithoutOneInput\`
 */
export type ManyRequiredUpdateManyWithoutOneInput = Prisma.ManyRequiredUpdateManyWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedUpdateManyWithoutOneInput\`
 */
export type ManyRequiredUncheckedUpdateManyWithoutOneInput = Prisma.ManyRequiredUncheckedUpdateManyWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCreateOneWithoutManyInput\`
 */
export type OneOptionalCreateOneWithoutManyInput = Prisma.OneOptionalCreateOneWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpdateOneWithoutManyInput\`
 */
export type OneOptionalUpdateOneWithoutManyInput = Prisma.OneOptionalUpdateOneWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CreateOneWithoutOptiInput\`
 */
export type OptionalSide2CreateOneWithoutOptiInput = Prisma.OptionalSide2CreateOneWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpdateOneWithoutOptiInput\`
 */
export type OptionalSide2UpdateOneWithoutOptiInput = Prisma.OptionalSide2UpdateOneWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CreateOneWithoutOptiInput\`
 */
export type OptionalSide1CreateOneWithoutOptiInput = Prisma.OptionalSide1CreateOneWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedCreateOneWithoutOptiInput\`
 */
export type OptionalSide1UncheckedCreateOneWithoutOptiInput = Prisma.OptionalSide1UncheckedCreateOneWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpdateOneWithoutOptiInput\`
 */
export type OptionalSide1UpdateOneWithoutOptiInput = Prisma.OptionalSide1UpdateOneWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedUpdateOneWithoutOptiInput\`
 */
export type OptionalSide1UncheckedUpdateOneWithoutOptiInput = Prisma.OptionalSide1UncheckedUpdateOneWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.BigIntFieldUpdateOperationsInput\`
 */
export type BigIntFieldUpdateOperationsInput = Prisma.BigIntFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.DecimalFieldUpdateOperationsInput\`
 */
export type DecimalFieldUpdateOperationsInput = Prisma.DecimalFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.BytesFieldUpdateOperationsInput\`
 */
export type BytesFieldUpdateOperationsInput = Prisma.BytesFieldUpdateOperationsInput

/**
 * @deprecated Renamed to \`Prisma.NestedIntFilter\`
 */
export type NestedIntFilter = Prisma.NestedIntFilter

/**
 * @deprecated Renamed to \`Prisma.NestedDateTimeFilter\`
 */
export type NestedDateTimeFilter = Prisma.NestedDateTimeFilter

/**
 * @deprecated Renamed to \`Prisma.NestedStringFilter\`
 */
export type NestedStringFilter = Prisma.NestedStringFilter

/**
 * @deprecated Renamed to \`Prisma.NestedStringNullableFilter\`
 */
export type NestedStringNullableFilter = Prisma.NestedStringNullableFilter

/**
 * @deprecated Renamed to \`Prisma.NestedBoolFilter\`
 */
export type NestedBoolFilter = Prisma.NestedBoolFilter

/**
 * @deprecated Renamed to \`Prisma.NestedIntNullableFilter\`
 */
export type NestedIntNullableFilter = Prisma.NestedIntNullableFilter

/**
 * @deprecated Renamed to \`Prisma.NestedFloatFilter\`
 */
export type NestedFloatFilter = Prisma.NestedFloatFilter

/**
 * @deprecated Renamed to \`Prisma.NestedFloatNullableFilter\`
 */
export type NestedFloatNullableFilter = Prisma.NestedFloatNullableFilter

/**
 * @deprecated Renamed to \`Prisma.NestedEnumABeautifulEnumFilter\`
 */
export type NestedEnumABeautifulEnumFilter = Prisma.NestedEnumABeautifulEnumFilter

/**
 * @deprecated Renamed to \`Prisma.NestedEnumABeautifulEnumNullableFilter\`
 */
export type NestedEnumABeautifulEnumNullableFilter = Prisma.NestedEnumABeautifulEnumNullableFilter

/**
 * @deprecated Renamed to \`Prisma.NestedBoolNullableFilter\`
 */
export type NestedBoolNullableFilter = Prisma.NestedBoolNullableFilter

/**
 * @deprecated Renamed to \`Prisma.NestedBigIntFilter\`
 */
export type NestedBigIntFilter = Prisma.NestedBigIntFilter

/**
 * @deprecated Renamed to \`Prisma.NestedDecimalFilter\`
 */
export type NestedDecimalFilter = Prisma.NestedDecimalFilter

/**
 * @deprecated Renamed to \`Prisma.NestedBytesFilter\`
 */
export type NestedBytesFilter = Prisma.NestedBytesFilter

/**
 * @deprecated Renamed to \`Prisma.UserCreateWithoutPostsInput\`
 */
export type UserCreateWithoutPostsInput = Prisma.UserCreateWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.UserUncheckedCreateWithoutPostsInput\`
 */
export type UserUncheckedCreateWithoutPostsInput = Prisma.UserUncheckedCreateWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.UserCreateOrConnectWithoutpostsInput\`
 */
export type UserCreateOrConnectWithoutpostsInput = Prisma.UserCreateOrConnectWithoutpostsInput

/**
 * @deprecated Renamed to \`Prisma.UserUpdateWithoutPostsInput\`
 */
export type UserUpdateWithoutPostsInput = Prisma.UserUpdateWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.UserUncheckedUpdateWithoutPostsInput\`
 */
export type UserUncheckedUpdateWithoutPostsInput = Prisma.UserUncheckedUpdateWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.UserUpsertWithoutPostsInput\`
 */
export type UserUpsertWithoutPostsInput = Prisma.UserUpsertWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.PostCreateWithoutAuthorInput\`
 */
export type PostCreateWithoutAuthorInput = Prisma.PostCreateWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedCreateWithoutAuthorInput\`
 */
export type PostUncheckedCreateWithoutAuthorInput = Prisma.PostUncheckedCreateWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostCreateOrConnectWithoutauthorInput\`
 */
export type PostCreateOrConnectWithoutauthorInput = Prisma.PostCreateOrConnectWithoutauthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUpdateWithWhereUniqueWithoutAuthorInput\`
 */
export type PostUpdateWithWhereUniqueWithoutAuthorInput = Prisma.PostUpdateWithWhereUniqueWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUpdateManyWithWhereWithoutAuthorInput\`
 */
export type PostUpdateManyWithWhereWithoutAuthorInput = Prisma.PostUpdateManyWithWhereWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostScalarWhereInput\`
 */
export type PostScalarWhereInput = Prisma.PostScalarWhereInput

/**
 * @deprecated Renamed to \`Prisma.PostUpsertWithWhereUniqueWithoutAuthorInput\`
 */
export type PostUpsertWithWhereUniqueWithoutAuthorInput = Prisma.PostUpsertWithWhereUniqueWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.NCreateWithoutMInput\`
 */
export type NCreateWithoutMInput = Prisma.NCreateWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NUncheckedCreateWithoutMInput\`
 */
export type NUncheckedCreateWithoutMInput = Prisma.NUncheckedCreateWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NCreateOrConnectWithoutmInput\`
 */
export type NCreateOrConnectWithoutmInput = Prisma.NCreateOrConnectWithoutmInput

/**
 * @deprecated Renamed to \`Prisma.NUpdateWithWhereUniqueWithoutMInput\`
 */
export type NUpdateWithWhereUniqueWithoutMInput = Prisma.NUpdateWithWhereUniqueWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NUpdateManyWithWhereWithoutMInput\`
 */
export type NUpdateManyWithWhereWithoutMInput = Prisma.NUpdateManyWithWhereWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NScalarWhereInput\`
 */
export type NScalarWhereInput = Prisma.NScalarWhereInput

/**
 * @deprecated Renamed to \`Prisma.NUpsertWithWhereUniqueWithoutMInput\`
 */
export type NUpsertWithWhereUniqueWithoutMInput = Prisma.NUpsertWithWhereUniqueWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.MCreateWithoutNInput\`
 */
export type MCreateWithoutNInput = Prisma.MCreateWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MUncheckedCreateWithoutNInput\`
 */
export type MUncheckedCreateWithoutNInput = Prisma.MUncheckedCreateWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MCreateOrConnectWithoutnInput\`
 */
export type MCreateOrConnectWithoutnInput = Prisma.MCreateOrConnectWithoutnInput

/**
 * @deprecated Renamed to \`Prisma.MUpdateWithWhereUniqueWithoutNInput\`
 */
export type MUpdateWithWhereUniqueWithoutNInput = Prisma.MUpdateWithWhereUniqueWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MUpdateManyWithWhereWithoutNInput\`
 */
export type MUpdateManyWithWhereWithoutNInput = Prisma.MUpdateManyWithWhereWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MScalarWhereInput\`
 */
export type MScalarWhereInput = Prisma.MScalarWhereInput

/**
 * @deprecated Renamed to \`Prisma.MUpsertWithWhereUniqueWithoutNInput\`
 */
export type MUpsertWithWhereUniqueWithoutNInput = Prisma.MUpsertWithWhereUniqueWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCreateWithoutOneInput\`
 */
export type ManyRequiredCreateWithoutOneInput = Prisma.ManyRequiredCreateWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedCreateWithoutOneInput\`
 */
export type ManyRequiredUncheckedCreateWithoutOneInput = Prisma.ManyRequiredUncheckedCreateWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredCreateOrConnectWithoutoneInput\`
 */
export type ManyRequiredCreateOrConnectWithoutoneInput = Prisma.ManyRequiredCreateOrConnectWithoutoneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateWithWhereUniqueWithoutOneInput\`
 */
export type ManyRequiredUpdateWithWhereUniqueWithoutOneInput = Prisma.ManyRequiredUpdateWithWhereUniqueWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateManyWithWhereWithoutOneInput\`
 */
export type ManyRequiredUpdateManyWithWhereWithoutOneInput = Prisma.ManyRequiredUpdateManyWithWhereWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredScalarWhereInput\`
 */
export type ManyRequiredScalarWhereInput = Prisma.ManyRequiredScalarWhereInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpsertWithWhereUniqueWithoutOneInput\`
 */
export type ManyRequiredUpsertWithWhereUniqueWithoutOneInput = Prisma.ManyRequiredUpsertWithWhereUniqueWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCreateWithoutManyInput\`
 */
export type OneOptionalCreateWithoutManyInput = Prisma.OneOptionalCreateWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUncheckedCreateWithoutManyInput\`
 */
export type OneOptionalUncheckedCreateWithoutManyInput = Prisma.OneOptionalUncheckedCreateWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalCreateOrConnectWithoutmanyInput\`
 */
export type OneOptionalCreateOrConnectWithoutmanyInput = Prisma.OneOptionalCreateOrConnectWithoutmanyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpdateWithoutManyInput\`
 */
export type OneOptionalUpdateWithoutManyInput = Prisma.OneOptionalUpdateWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUncheckedUpdateWithoutManyInput\`
 */
export type OneOptionalUncheckedUpdateWithoutManyInput = Prisma.OneOptionalUncheckedUpdateWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OneOptionalUpsertWithoutManyInput\`
 */
export type OneOptionalUpsertWithoutManyInput = Prisma.OneOptionalUpsertWithoutManyInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CreateWithoutOptiInput\`
 */
export type OptionalSide2CreateWithoutOptiInput = Prisma.OptionalSide2CreateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UncheckedCreateWithoutOptiInput\`
 */
export type OptionalSide2UncheckedCreateWithoutOptiInput = Prisma.OptionalSide2UncheckedCreateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2CreateOrConnectWithoutoptiInput\`
 */
export type OptionalSide2CreateOrConnectWithoutoptiInput = Prisma.OptionalSide2CreateOrConnectWithoutoptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpdateWithoutOptiInput\`
 */
export type OptionalSide2UpdateWithoutOptiInput = Prisma.OptionalSide2UpdateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UncheckedUpdateWithoutOptiInput\`
 */
export type OptionalSide2UncheckedUpdateWithoutOptiInput = Prisma.OptionalSide2UncheckedUpdateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide2UpsertWithoutOptiInput\`
 */
export type OptionalSide2UpsertWithoutOptiInput = Prisma.OptionalSide2UpsertWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CreateWithoutOptiInput\`
 */
export type OptionalSide1CreateWithoutOptiInput = Prisma.OptionalSide1CreateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedCreateWithoutOptiInput\`
 */
export type OptionalSide1UncheckedCreateWithoutOptiInput = Prisma.OptionalSide1UncheckedCreateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1CreateOrConnectWithoutoptiInput\`
 */
export type OptionalSide1CreateOrConnectWithoutoptiInput = Prisma.OptionalSide1CreateOrConnectWithoutoptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpdateWithoutOptiInput\`
 */
export type OptionalSide1UpdateWithoutOptiInput = Prisma.OptionalSide1UpdateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UncheckedUpdateWithoutOptiInput\`
 */
export type OptionalSide1UncheckedUpdateWithoutOptiInput = Prisma.OptionalSide1UncheckedUpdateWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.OptionalSide1UpsertWithoutOptiInput\`
 */
export type OptionalSide1UpsertWithoutOptiInput = Prisma.OptionalSide1UpsertWithoutOptiInput

/**
 * @deprecated Renamed to \`Prisma.PostUpdateWithoutAuthorInput\`
 */
export type PostUpdateWithoutAuthorInput = Prisma.PostUpdateWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedUpdateWithoutAuthorInput\`
 */
export type PostUncheckedUpdateWithoutAuthorInput = Prisma.PostUncheckedUpdateWithoutAuthorInput

/**
 * @deprecated Renamed to \`Prisma.PostUncheckedUpdateManyWithoutPostsInput\`
 */
export type PostUncheckedUpdateManyWithoutPostsInput = Prisma.PostUncheckedUpdateManyWithoutPostsInput

/**
 * @deprecated Renamed to \`Prisma.NUpdateWithoutMInput\`
 */
export type NUpdateWithoutMInput = Prisma.NUpdateWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NUncheckedUpdateWithoutMInput\`
 */
export type NUncheckedUpdateWithoutMInput = Prisma.NUncheckedUpdateWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.NUncheckedUpdateManyWithoutNInput\`
 */
export type NUncheckedUpdateManyWithoutNInput = Prisma.NUncheckedUpdateManyWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MUpdateWithoutNInput\`
 */
export type MUpdateWithoutNInput = Prisma.MUpdateWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MUncheckedUpdateWithoutNInput\`
 */
export type MUncheckedUpdateWithoutNInput = Prisma.MUncheckedUpdateWithoutNInput

/**
 * @deprecated Renamed to \`Prisma.MUncheckedUpdateManyWithoutMInput\`
 */
export type MUncheckedUpdateManyWithoutMInput = Prisma.MUncheckedUpdateManyWithoutMInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUpdateWithoutOneInput\`
 */
export type ManyRequiredUpdateWithoutOneInput = Prisma.ManyRequiredUpdateWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedUpdateWithoutOneInput\`
 */
export type ManyRequiredUncheckedUpdateWithoutOneInput = Prisma.ManyRequiredUncheckedUpdateWithoutOneInput

/**
 * @deprecated Renamed to \`Prisma.ManyRequiredUncheckedUpdateManyWithoutManyInput\`
 */
export type ManyRequiredUncheckedUpdateManyWithoutManyInput = Prisma.ManyRequiredUncheckedUpdateManyWithoutManyInput
`;