/**
 * Client
**/

import * as runtime from './runtime/library.js';
import $Types = runtime.Types // general types
import $Public = runtime.Types.Public
import $Utils = runtime.Types.Utils
import $Extensions = runtime.Types.Extensions
import $Result = runtime.Types.Result

export type PrismaPromise<T> = $Public.PrismaPromise<T>


/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model Account
 * 
 */
export type Account = $Result.DefaultSelection<Prisma.$AccountPayload>
/**
 * Model Session
 * 
 */
export type Session = $Result.DefaultSelection<Prisma.$SessionPayload>
/**
 * Model Otp
 * 
 */
export type Otp = $Result.DefaultSelection<Prisma.$OtpPayload>
/**
 * Model KoasProfile
 * 
 */
export type KoasProfile = $Result.DefaultSelection<Prisma.$KoasProfilePayload>
/**
 * Model PasienProfile
 * 
 */
export type PasienProfile = $Result.DefaultSelection<Prisma.$PasienProfilePayload>
/**
 * Model FasilitatorProfile
 * 
 */
export type FasilitatorProfile = $Result.DefaultSelection<Prisma.$FasilitatorProfilePayload>
/**
 * Model University
 * 
 */
export type University = $Result.DefaultSelection<Prisma.$UniversityPayload>
/**
 * Model Post
 * 
 */
export type Post = $Result.DefaultSelection<Prisma.$PostPayload>
/**
 * Model Like
 * 
 */
export type Like = $Result.DefaultSelection<Prisma.$LikePayload>
/**
 * Model Notification
 * 
 */
export type Notification = $Result.DefaultSelection<Prisma.$NotificationPayload>
/**
 * Model TreatmentType
 * 
 */
export type TreatmentType = $Result.DefaultSelection<Prisma.$TreatmentTypePayload>
/**
 * Model Schedule
 * 
 */
export type Schedule = $Result.DefaultSelection<Prisma.$SchedulePayload>
/**
 * Model Timeslot
 * 
 */
export type Timeslot = $Result.DefaultSelection<Prisma.$TimeslotPayload>
/**
 * Model Review
 * 
 */
export type Review = $Result.DefaultSelection<Prisma.$ReviewPayload>
/**
 * Model Appointment
 * 
 */
export type Appointment = $Result.DefaultSelection<Prisma.$AppointmentPayload>
/**
 * Model verificationrequest
 * 
 */
export type verificationrequest = $Result.DefaultSelection<Prisma.$verificationrequestPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const Role: {
  Admin: 'Admin',
  Koas: 'Koas',
  Pasien: 'Pasien',
  Fasilitator: 'Fasilitator'
};

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


export const StatusPost: {
  Pending: 'Pending',
  Open: 'Open',
  Closed: 'Closed'
};

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


export const StatusKoas: {
  Rejected: 'Rejected',
  Pending: 'Pending',
  Approved: 'Approved'
};

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


export const StatusAppointment: {
  Canceled: 'Canceled',
  Rejected: 'Rejected',
  Pending: 'Pending',
  Confirmed: 'Confirmed',
  Ongoing: 'Ongoing',
  Completed: 'Completed'
};

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


export const StatusNotification: {
  Unread: 'Unread',
  Read: 'Read'
};

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

}

export type Role = $Enums.Role

export const Role: typeof $Enums.Role

export type StatusPost = $Enums.StatusPost

export const StatusPost: typeof $Enums.StatusPost

export type StatusKoas = $Enums.StatusKoas

export const StatusKoas: typeof $Enums.StatusKoas

export type StatusAppointment = $Enums.StatusAppointment

export const StatusAppointment: typeof $Enums.StatusAppointment

export type StatusNotification = $Enums.StatusNotification

export const StatusNotification: typeof $Enums.StatusNotification

/**
 * ##  Prisma Client ʲˢ
 *
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Users
 * const users = await prisma.user.findMany()
 * ```
 *
 *
 * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
 */
export class PrismaClient<
  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
> {
  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }

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

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

  /**
   * Connect with the database
   */
  $connect(): $Utils.JsPromise<void>;

  /**
   * Disconnect from the database
   */
  $disconnect(): $Utils.JsPromise<void>;

  /**
   * Add a middleware
   * @deprecated since 4.16.0. For new code, prefer client extensions instead.
   * @see https://pris.ly/d/extensions
   */
  $use(cb: Prisma.Middleware): void

/**
   * Executes a prepared raw query and returns the number of affected rows.
   * @example
   * ```
   * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;

  /**
   * Executes a raw query and returns the number of affected rows.
   * Susceptible to SQL injections, see documentation.
   * @example
   * ```
   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;

  /**
   * Performs a prepared raw query and returns the `SELECT` data.
   * @example
   * ```
   * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;

  /**
   * Performs a raw query and returns the `SELECT` data.
   * Susceptible to SQL injections, see documentation.
   * @example
   * ```
   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
   * ```
   *
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;


  /**
   * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
   * @example
   * ```
   * const [george, bob, alice] = await prisma.$transaction([
   *   prisma.user.create({ data: { name: 'George' } }),
   *   prisma.user.create({ data: { name: 'Bob' } }),
   *   prisma.user.create({ data: { name: 'Alice' } }),
   * ])
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
   */
  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>

  $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => $Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<R>


  $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<ClientOptions>, ExtArgs, $Utils.Call<Prisma.TypeMapCb<ClientOptions>, {
    extArgs: ExtArgs
  }>>

      /**
   * `prisma.user`: Exposes CRUD operations for the **User** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Users
    * const users = await prisma.user.findMany()
    * ```
    */
  get user(): Prisma.UserDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.account`: Exposes CRUD operations for the **Account** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Accounts
    * const accounts = await prisma.account.findMany()
    * ```
    */
  get account(): Prisma.AccountDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.session`: Exposes CRUD operations for the **Session** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Sessions
    * const sessions = await prisma.session.findMany()
    * ```
    */
  get session(): Prisma.SessionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.otp`: Exposes CRUD operations for the **Otp** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Otps
    * const otps = await prisma.otp.findMany()
    * ```
    */
  get otp(): Prisma.OtpDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.koasProfile`: Exposes CRUD operations for the **KoasProfile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more KoasProfiles
    * const koasProfiles = await prisma.koasProfile.findMany()
    * ```
    */
  get koasProfile(): Prisma.KoasProfileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.pasienProfile`: Exposes CRUD operations for the **PasienProfile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PasienProfiles
    * const pasienProfiles = await prisma.pasienProfile.findMany()
    * ```
    */
  get pasienProfile(): Prisma.PasienProfileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.fasilitatorProfile`: Exposes CRUD operations for the **FasilitatorProfile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more FasilitatorProfiles
    * const fasilitatorProfiles = await prisma.fasilitatorProfile.findMany()
    * ```
    */
  get fasilitatorProfile(): Prisma.FasilitatorProfileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.university`: Exposes CRUD operations for the **University** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Universities
    * const universities = await prisma.university.findMany()
    * ```
    */
  get university(): Prisma.UniversityDelegate<ExtArgs, ClientOptions>;

  /**
   * `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<ExtArgs, ClientOptions>;

  /**
   * `prisma.like`: Exposes CRUD operations for the **Like** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Likes
    * const likes = await prisma.like.findMany()
    * ```
    */
  get like(): Prisma.LikeDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.notification`: Exposes CRUD operations for the **Notification** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Notifications
    * const notifications = await prisma.notification.findMany()
    * ```
    */
  get notification(): Prisma.NotificationDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.treatmentType`: Exposes CRUD operations for the **TreatmentType** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more TreatmentTypes
    * const treatmentTypes = await prisma.treatmentType.findMany()
    * ```
    */
  get treatmentType(): Prisma.TreatmentTypeDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.schedule`: Exposes CRUD operations for the **Schedule** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Schedules
    * const schedules = await prisma.schedule.findMany()
    * ```
    */
  get schedule(): Prisma.ScheduleDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.timeslot`: Exposes CRUD operations for the **Timeslot** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Timeslots
    * const timeslots = await prisma.timeslot.findMany()
    * ```
    */
  get timeslot(): Prisma.TimeslotDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.review`: Exposes CRUD operations for the **Review** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Reviews
    * const reviews = await prisma.review.findMany()
    * ```
    */
  get review(): Prisma.ReviewDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.appointment`: Exposes CRUD operations for the **Appointment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Appointments
    * const appointments = await prisma.appointment.findMany()
    * ```
    */
  get appointment(): Prisma.AppointmentDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.verificationrequest`: Exposes CRUD operations for the **verificationrequest** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Verificationrequests
    * const verificationrequests = await prisma.verificationrequest.findMany()
    * ```
    */
  get verificationrequest(): Prisma.verificationrequestDelegate<ExtArgs, ClientOptions>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

  export type PrismaPromise<T> = $Public.PrismaPromise<T>

  /**
   * Validator
   */
  export import validator = runtime.Public.validator

  /**
   * Prisma Errors
   */
  export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
  export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
  export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
  export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
  export import PrismaClientValidationError = runtime.PrismaClientValidationError

  /**
   * Re-export of sql-template-tag
   */
  export import sql = runtime.sqltag
  export import empty = runtime.empty
  export import join = runtime.join
  export import raw = runtime.raw
  export import Sql = runtime.Sql



  /**
   * Decimal.js
   */
  export import Decimal = runtime.Decimal

  export type DecimalJsLike = runtime.DecimalJsLike

  /**
   * Metrics
   */
  export type Metrics = runtime.Metrics
  export type Metric<T> = runtime.Metric<T>
  export type MetricHistogram = runtime.MetricHistogram
  export type MetricHistogramBucket = runtime.MetricHistogramBucket

  /**
  * Extensions
  */
  export import Extension = $Extensions.UserArgs
  export import getExtensionContext = runtime.Extensions.getExtensionContext
  export import Args = $Public.Args
  export import Payload = $Public.Payload
  export import Result = $Public.Result
  export import Exact = $Public.Exact

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

  export const prismaVersion: PrismaVersion

  /**
   * Utility Types
   */


  export import JsonObject = runtime.JsonObject
  export import JsonArray = runtime.JsonArray
  export import JsonValue = runtime.JsonValue
  export import InputJsonObject = runtime.InputJsonObject
  export import InputJsonArray = runtime.InputJsonArray
  export import InputJsonValue = runtime.InputJsonValue

  /**
   * Types of the values used to represent different kinds of `null` values when working with JSON fields.
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  namespace NullTypes {
    /**
    * Type of `Prisma.DbNull`.
    *
    * You cannot use other instances of this class. Please use the `Prisma.DbNull` value.
    *
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class DbNull {
      private DbNull: never
      private constructor()
    }

    /**
    * Type of `Prisma.JsonNull`.
    *
    * You cannot use other instances of this class. Please use the `Prisma.JsonNull` value.
    *
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class JsonNull {
      private JsonNull: never
      private constructor()
    }

    /**
    * Type of `Prisma.AnyNull`.
    *
    * You cannot use other instances of this class. Please use the `Prisma.AnyNull` value.
    *
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class AnyNull {
      private AnyNull: never
      private constructor()
    }
  }

  /**
   * Helper for filtering JSON entries that have `null` on the database (empty on the db)
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  export const DbNull: NullTypes.DbNull

  /**
   * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  export const JsonNull: NullTypes.JsonNull

  /**
   * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  export const AnyNull: NullTypes.AnyNull

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

  /**
   * Get the type of the value, that the Promise holds.
   */
  export type PromiseType<T extends PromiseLike<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) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>

  /**
   * From T, pick a set of properties whose keys are in the union K
   */
  type Prisma__Pick<T, K extends keyof T> = {
      [P in K]: T[P];
  };


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

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

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

  export type TrueKeys<T> = TruthyKeys<Prisma__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;
  };

  /**
   * SelectSubset
   * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
   * Additionally, it validates, if both select and include are present. If the case, it errors.
   */
  export type SelectSubset<T, U> = {
    [key in keyof T]: key extends keyof U ? T[key] : never
  } &
    (T extends SelectAndInclude
      ? 'Please either choose `select` or `include`.'
      : T extends SelectAndOmit
        ? 'Please either choose `select` or `omit`.'
        : {})

  /**
   * Subset + Intersection
   * @desc From `T` pick properties that exist in `U` and intersect `K`
   */
  export type SubsetIntersection<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 extends object ?
    U extends object ?
      (Without<T, U> & U) | (Without<U, T> & T)
    : U : T


  /**
   * Is T a Record?
   */
  type IsObject<T extends any> = T extends Array<any>
  ? False
  : T extends Date
  ? False
  : T extends Uint8Array
  ? False
  : T extends BigInt
  ? False
  : T extends object
  ? True
  : False


  /**
   * If it's T[], return T
   */
  export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T

  /**
   * From ts-toolbelt
   */

  type __Either<O extends object, K extends Key> = Omit<O, K> &
    {
      // Merge all but K
      [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
    }[K]

  type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>

  type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>

  type _Either<
    O extends object,
    K extends Key,
    strict extends Boolean
  > = {
    1: EitherStrict<O, K>
    0: EitherLoose<O, K>
  }[strict]

  type Either<
    O extends object,
    K extends Key,
    strict extends Boolean = 1
  > = O extends unknown ? _Either<O, K, strict> : never

  export type Union = any

  type PatchUndefined<O extends object, O1 extends object> = {
    [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
  } & {}

  /** Helper Types for "Merge" **/
  export type IntersectOf<U extends Union> = (
    U extends unknown ? (k: U) => void : never
  ) extends (k: infer I) => void
    ? I
    : never

  export type Overwrite<O extends object, O1 extends object> = {
      [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
  } & {};

  type _Merge<U extends object> = IntersectOf<Overwrite<U, {
      [K in keyof U]-?: At<U, K>;
  }>>;

  type Key = string | number | symbol;
  type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
  type AtStrict<O extends object, K extends Key> = O[K & keyof O];
  type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
  export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
      1: AtStrict<O, K>;
      0: AtLoose<O, K>;
  }[strict];

  export type ComputeRaw<A extends any> = A extends Function ? A : {
    [K in keyof A]: A[K];
  } & {};

  export type OptionalFlat<O> = {
    [K in keyof O]?: O[K];
  } & {};

  type _Record<K extends keyof any, T> = {
    [P in K]: T;
  };

  // cause typescript not to expand types and preserve names
  type NoExpand<T> = T extends unknown ? T : never;

  // this type assumes the passed object is entirely optional
  type AtLeast<O extends object, K extends string> = NoExpand<
    O extends unknown
    ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
      | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
    : never>;

  type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;

  export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
  /** End Helper Types for "Merge" **/

  export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;

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

  type Cast<A, B> = A extends B ? A : B;

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

  type FieldPaths<
    T,
    U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
  > = IsObject<T> extends True ? U : T

  type GetHavingFields<T> = {
    [K in keyof T]: Or<
      Or<Extends<'OR', K>, Extends<'AND', K>>,
      Extends<'NOT', K>
    > extends True
      ? // infer is only needed to not hit TS limit
        // based on the brilliant idea of Pierre-Antoine Mills
        // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
        T[K] extends infer TK
        ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
        : never
      : {} extends FieldPaths<T[K]>
      ? never
      : K
  }[keyof T]

  /**
   * 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 additionally can also accept an array of keys
   */
  type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>

  /**
   * Exclude all keys with underscores
   */
  type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T


  export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>

  type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>


  export const ModelName: {
    User: 'User',
    Account: 'Account',
    Session: 'Session',
    Otp: 'Otp',
    KoasProfile: 'KoasProfile',
    PasienProfile: 'PasienProfile',
    FasilitatorProfile: 'FasilitatorProfile',
    University: 'University',
    Post: 'Post',
    Like: 'Like',
    Notification: 'Notification',
    TreatmentType: 'TreatmentType',
    Schedule: 'Schedule',
    Timeslot: 'Timeslot',
    Review: 'Review',
    Appointment: 'Appointment',
    verificationrequest: 'verificationrequest'
  };

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


  export type Datasources = {
    db?: Datasource
  }

  interface TypeMapCb<ClientOptions = {}> extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record<string, any>> {
    returns: Prisma.TypeMap<this['params']['extArgs'], ClientOptions extends { omit: infer OmitOptions } ? OmitOptions : {}>
  }

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions
    }
    meta: {
      modelProps: "user" | "account" | "session" | "otp" | "koasProfile" | "pasienProfile" | "fasilitatorProfile" | "university" | "post" | "like" | "notification" | "treatmentType" | "schedule" | "timeslot" | "review" | "appointment" | "verificationrequest"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      Account: {
        payload: Prisma.$AccountPayload<ExtArgs>
        fields: Prisma.AccountFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AccountFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AccountFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findFirst: {
            args: Prisma.AccountFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AccountFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findMany: {
            args: Prisma.AccountFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          create: {
            args: Prisma.AccountCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          createMany: {
            args: Prisma.AccountCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.AccountDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          update: {
            args: Prisma.AccountUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          deleteMany: {
            args: Prisma.AccountDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AccountUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AccountUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          aggregate: {
            args: Prisma.AccountAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAccount>
          }
          groupBy: {
            args: Prisma.AccountGroupByArgs<ExtArgs>
            result: $Utils.Optional<AccountGroupByOutputType>[]
          }
          count: {
            args: Prisma.AccountCountArgs<ExtArgs>
            result: $Utils.Optional<AccountCountAggregateOutputType> | number
          }
        }
      }
      Session: {
        payload: Prisma.$SessionPayload<ExtArgs>
        fields: Prisma.SessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findFirst: {
            args: Prisma.SessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          findMany: {
            args: Prisma.SessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>[]
          }
          create: {
            args: Prisma.SessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          createMany: {
            args: Prisma.SessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.SessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          update: {
            args: Prisma.SessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          deleteMany: {
            args: Prisma.SessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SessionPayload>
          }
          aggregate: {
            args: Prisma.SessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSession>
          }
          groupBy: {
            args: Prisma.SessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SessionCountArgs<ExtArgs>
            result: $Utils.Optional<SessionCountAggregateOutputType> | number
          }
        }
      }
      Otp: {
        payload: Prisma.$OtpPayload<ExtArgs>
        fields: Prisma.OtpFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OtpFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OtpFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>
          }
          findFirst: {
            args: Prisma.OtpFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OtpFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>
          }
          findMany: {
            args: Prisma.OtpFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>[]
          }
          create: {
            args: Prisma.OtpCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>
          }
          createMany: {
            args: Prisma.OtpCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.OtpDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>
          }
          update: {
            args: Prisma.OtpUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>
          }
          deleteMany: {
            args: Prisma.OtpDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OtpUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.OtpUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OtpPayload>
          }
          aggregate: {
            args: Prisma.OtpAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOtp>
          }
          groupBy: {
            args: Prisma.OtpGroupByArgs<ExtArgs>
            result: $Utils.Optional<OtpGroupByOutputType>[]
          }
          count: {
            args: Prisma.OtpCountArgs<ExtArgs>
            result: $Utils.Optional<OtpCountAggregateOutputType> | number
          }
        }
      }
      KoasProfile: {
        payload: Prisma.$KoasProfilePayload<ExtArgs>
        fields: Prisma.KoasProfileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.KoasProfileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.KoasProfileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>
          }
          findFirst: {
            args: Prisma.KoasProfileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.KoasProfileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>
          }
          findMany: {
            args: Prisma.KoasProfileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>[]
          }
          create: {
            args: Prisma.KoasProfileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>
          }
          createMany: {
            args: Prisma.KoasProfileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.KoasProfileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>
          }
          update: {
            args: Prisma.KoasProfileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>
          }
          deleteMany: {
            args: Prisma.KoasProfileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.KoasProfileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.KoasProfileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$KoasProfilePayload>
          }
          aggregate: {
            args: Prisma.KoasProfileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateKoasProfile>
          }
          groupBy: {
            args: Prisma.KoasProfileGroupByArgs<ExtArgs>
            result: $Utils.Optional<KoasProfileGroupByOutputType>[]
          }
          count: {
            args: Prisma.KoasProfileCountArgs<ExtArgs>
            result: $Utils.Optional<KoasProfileCountAggregateOutputType> | number
          }
        }
      }
      PasienProfile: {
        payload: Prisma.$PasienProfilePayload<ExtArgs>
        fields: Prisma.PasienProfileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PasienProfileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PasienProfileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>
          }
          findFirst: {
            args: Prisma.PasienProfileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PasienProfileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>
          }
          findMany: {
            args: Prisma.PasienProfileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>[]
          }
          create: {
            args: Prisma.PasienProfileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>
          }
          createMany: {
            args: Prisma.PasienProfileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.PasienProfileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>
          }
          update: {
            args: Prisma.PasienProfileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>
          }
          deleteMany: {
            args: Prisma.PasienProfileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PasienProfileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PasienProfileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PasienProfilePayload>
          }
          aggregate: {
            args: Prisma.PasienProfileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePasienProfile>
          }
          groupBy: {
            args: Prisma.PasienProfileGroupByArgs<ExtArgs>
            result: $Utils.Optional<PasienProfileGroupByOutputType>[]
          }
          count: {
            args: Prisma.PasienProfileCountArgs<ExtArgs>
            result: $Utils.Optional<PasienProfileCountAggregateOutputType> | number
          }
        }
      }
      FasilitatorProfile: {
        payload: Prisma.$FasilitatorProfilePayload<ExtArgs>
        fields: Prisma.FasilitatorProfileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FasilitatorProfileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FasilitatorProfileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>
          }
          findFirst: {
            args: Prisma.FasilitatorProfileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FasilitatorProfileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>
          }
          findMany: {
            args: Prisma.FasilitatorProfileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>[]
          }
          create: {
            args: Prisma.FasilitatorProfileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>
          }
          createMany: {
            args: Prisma.FasilitatorProfileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.FasilitatorProfileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>
          }
          update: {
            args: Prisma.FasilitatorProfileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>
          }
          deleteMany: {
            args: Prisma.FasilitatorProfileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FasilitatorProfileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FasilitatorProfileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FasilitatorProfilePayload>
          }
          aggregate: {
            args: Prisma.FasilitatorProfileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFasilitatorProfile>
          }
          groupBy: {
            args: Prisma.FasilitatorProfileGroupByArgs<ExtArgs>
            result: $Utils.Optional<FasilitatorProfileGroupByOutputType>[]
          }
          count: {
            args: Prisma.FasilitatorProfileCountArgs<ExtArgs>
            result: $Utils.Optional<FasilitatorProfileCountAggregateOutputType> | number
          }
        }
      }
      University: {
        payload: Prisma.$UniversityPayload<ExtArgs>
        fields: Prisma.UniversityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UniversityFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UniversityFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>
          }
          findFirst: {
            args: Prisma.UniversityFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UniversityFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>
          }
          findMany: {
            args: Prisma.UniversityFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>[]
          }
          create: {
            args: Prisma.UniversityCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>
          }
          createMany: {
            args: Prisma.UniversityCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UniversityDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>
          }
          update: {
            args: Prisma.UniversityUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>
          }
          deleteMany: {
            args: Prisma.UniversityDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UniversityUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UniversityUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UniversityPayload>
          }
          aggregate: {
            args: Prisma.UniversityAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUniversity>
          }
          groupBy: {
            args: Prisma.UniversityGroupByArgs<ExtArgs>
            result: $Utils.Optional<UniversityGroupByOutputType>[]
          }
          count: {
            args: Prisma.UniversityCountArgs<ExtArgs>
            result: $Utils.Optional<UniversityCountAggregateOutputType> | number
          }
        }
      }
      Post: {
        payload: Prisma.$PostPayload<ExtArgs>
        fields: Prisma.PostFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PostFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PostFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>
          }
          findFirst: {
            args: Prisma.PostFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PostFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>
          }
          findMany: {
            args: Prisma.PostFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>[]
          }
          create: {
            args: Prisma.PostCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>
          }
          createMany: {
            args: Prisma.PostCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.PostDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>
          }
          update: {
            args: Prisma.PostUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>
          }
          deleteMany: {
            args: Prisma.PostDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PostUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PostUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PostPayload>
          }
          aggregate: {
            args: Prisma.PostAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePost>
          }
          groupBy: {
            args: Prisma.PostGroupByArgs<ExtArgs>
            result: $Utils.Optional<PostGroupByOutputType>[]
          }
          count: {
            args: Prisma.PostCountArgs<ExtArgs>
            result: $Utils.Optional<PostCountAggregateOutputType> | number
          }
        }
      }
      Like: {
        payload: Prisma.$LikePayload<ExtArgs>
        fields: Prisma.LikeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LikeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LikeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>
          }
          findFirst: {
            args: Prisma.LikeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LikeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>
          }
          findMany: {
            args: Prisma.LikeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>[]
          }
          create: {
            args: Prisma.LikeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>
          }
          createMany: {
            args: Prisma.LikeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.LikeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>
          }
          update: {
            args: Prisma.LikeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>
          }
          deleteMany: {
            args: Prisma.LikeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LikeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LikeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LikePayload>
          }
          aggregate: {
            args: Prisma.LikeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLike>
          }
          groupBy: {
            args: Prisma.LikeGroupByArgs<ExtArgs>
            result: $Utils.Optional<LikeGroupByOutputType>[]
          }
          count: {
            args: Prisma.LikeCountArgs<ExtArgs>
            result: $Utils.Optional<LikeCountAggregateOutputType> | number
          }
        }
      }
      Notification: {
        payload: Prisma.$NotificationPayload<ExtArgs>
        fields: Prisma.NotificationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NotificationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NotificationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findFirst: {
            args: Prisma.NotificationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NotificationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findMany: {
            args: Prisma.NotificationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          create: {
            args: Prisma.NotificationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          createMany: {
            args: Prisma.NotificationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.NotificationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          update: {
            args: Prisma.NotificationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          deleteMany: {
            args: Prisma.NotificationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.NotificationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.NotificationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          aggregate: {
            args: Prisma.NotificationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateNotification>
          }
          groupBy: {
            args: Prisma.NotificationGroupByArgs<ExtArgs>
            result: $Utils.Optional<NotificationGroupByOutputType>[]
          }
          count: {
            args: Prisma.NotificationCountArgs<ExtArgs>
            result: $Utils.Optional<NotificationCountAggregateOutputType> | number
          }
        }
      }
      TreatmentType: {
        payload: Prisma.$TreatmentTypePayload<ExtArgs>
        fields: Prisma.TreatmentTypeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TreatmentTypeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TreatmentTypeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>
          }
          findFirst: {
            args: Prisma.TreatmentTypeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TreatmentTypeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>
          }
          findMany: {
            args: Prisma.TreatmentTypeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>[]
          }
          create: {
            args: Prisma.TreatmentTypeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>
          }
          createMany: {
            args: Prisma.TreatmentTypeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.TreatmentTypeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>
          }
          update: {
            args: Prisma.TreatmentTypeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>
          }
          deleteMany: {
            args: Prisma.TreatmentTypeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TreatmentTypeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TreatmentTypeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TreatmentTypePayload>
          }
          aggregate: {
            args: Prisma.TreatmentTypeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTreatmentType>
          }
          groupBy: {
            args: Prisma.TreatmentTypeGroupByArgs<ExtArgs>
            result: $Utils.Optional<TreatmentTypeGroupByOutputType>[]
          }
          count: {
            args: Prisma.TreatmentTypeCountArgs<ExtArgs>
            result: $Utils.Optional<TreatmentTypeCountAggregateOutputType> | number
          }
        }
      }
      Schedule: {
        payload: Prisma.$SchedulePayload<ExtArgs>
        fields: Prisma.ScheduleFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ScheduleFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ScheduleFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>
          }
          findFirst: {
            args: Prisma.ScheduleFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ScheduleFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>
          }
          findMany: {
            args: Prisma.ScheduleFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>[]
          }
          create: {
            args: Prisma.ScheduleCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>
          }
          createMany: {
            args: Prisma.ScheduleCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ScheduleDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>
          }
          update: {
            args: Prisma.ScheduleUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>
          }
          deleteMany: {
            args: Prisma.ScheduleDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ScheduleUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ScheduleUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SchedulePayload>
          }
          aggregate: {
            args: Prisma.ScheduleAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSchedule>
          }
          groupBy: {
            args: Prisma.ScheduleGroupByArgs<ExtArgs>
            result: $Utils.Optional<ScheduleGroupByOutputType>[]
          }
          count: {
            args: Prisma.ScheduleCountArgs<ExtArgs>
            result: $Utils.Optional<ScheduleCountAggregateOutputType> | number
          }
        }
      }
      Timeslot: {
        payload: Prisma.$TimeslotPayload<ExtArgs>
        fields: Prisma.TimeslotFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TimeslotFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TimeslotFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>
          }
          findFirst: {
            args: Prisma.TimeslotFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TimeslotFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>
          }
          findMany: {
            args: Prisma.TimeslotFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>[]
          }
          create: {
            args: Prisma.TimeslotCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>
          }
          createMany: {
            args: Prisma.TimeslotCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.TimeslotDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>
          }
          update: {
            args: Prisma.TimeslotUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>
          }
          deleteMany: {
            args: Prisma.TimeslotDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TimeslotUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TimeslotUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TimeslotPayload>
          }
          aggregate: {
            args: Prisma.TimeslotAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTimeslot>
          }
          groupBy: {
            args: Prisma.TimeslotGroupByArgs<ExtArgs>
            result: $Utils.Optional<TimeslotGroupByOutputType>[]
          }
          count: {
            args: Prisma.TimeslotCountArgs<ExtArgs>
            result: $Utils.Optional<TimeslotCountAggregateOutputType> | number
          }
        }
      }
      Review: {
        payload: Prisma.$ReviewPayload<ExtArgs>
        fields: Prisma.ReviewFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ReviewFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ReviewFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>
          }
          findFirst: {
            args: Prisma.ReviewFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ReviewFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>
          }
          findMany: {
            args: Prisma.ReviewFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>[]
          }
          create: {
            args: Prisma.ReviewCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>
          }
          createMany: {
            args: Prisma.ReviewCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ReviewDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>
          }
          update: {
            args: Prisma.ReviewUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>
          }
          deleteMany: {
            args: Prisma.ReviewDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ReviewUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ReviewUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ReviewPayload>
          }
          aggregate: {
            args: Prisma.ReviewAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateReview>
          }
          groupBy: {
            args: Prisma.ReviewGroupByArgs<ExtArgs>
            result: $Utils.Optional<ReviewGroupByOutputType>[]
          }
          count: {
            args: Prisma.ReviewCountArgs<ExtArgs>
            result: $Utils.Optional<ReviewCountAggregateOutputType> | number
          }
        }
      }
      Appointment: {
        payload: Prisma.$AppointmentPayload<ExtArgs>
        fields: Prisma.AppointmentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppointmentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppointmentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          findFirst: {
            args: Prisma.AppointmentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppointmentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          findMany: {
            args: Prisma.AppointmentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>[]
          }
          create: {
            args: Prisma.AppointmentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          createMany: {
            args: Prisma.AppointmentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.AppointmentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          update: {
            args: Prisma.AppointmentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          deleteMany: {
            args: Prisma.AppointmentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AppointmentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AppointmentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppointmentPayload>
          }
          aggregate: {
            args: Prisma.AppointmentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAppointment>
          }
          groupBy: {
            args: Prisma.AppointmentGroupByArgs<ExtArgs>
            result: $Utils.Optional<AppointmentGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppointmentCountArgs<ExtArgs>
            result: $Utils.Optional<AppointmentCountAggregateOutputType> | number
          }
        }
      }
      verificationrequest: {
        payload: Prisma.$verificationrequestPayload<ExtArgs>
        fields: Prisma.verificationrequestFieldRefs
        operations: {
          findUnique: {
            args: Prisma.verificationrequestFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.verificationrequestFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>
          }
          findFirst: {
            args: Prisma.verificationrequestFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.verificationrequestFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>
          }
          findMany: {
            args: Prisma.verificationrequestFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>[]
          }
          create: {
            args: Prisma.verificationrequestCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>
          }
          createMany: {
            args: Prisma.verificationrequestCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.verificationrequestDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>
          }
          update: {
            args: Prisma.verificationrequestUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>
          }
          deleteMany: {
            args: Prisma.verificationrequestDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.verificationrequestUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.verificationrequestUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$verificationrequestPayload>
          }
          aggregate: {
            args: Prisma.VerificationrequestAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVerificationrequest>
          }
          groupBy: {
            args: Prisma.verificationrequestGroupByArgs<ExtArgs>
            result: $Utils.Optional<VerificationrequestGroupByOutputType>[]
          }
          count: {
            args: Prisma.verificationrequestCountArgs<ExtArgs>
            result: $Utils.Optional<VerificationrequestCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
      }
    }
  }
  export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
  export type DefaultPrismaClient = PrismaClient
  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasources?: Datasources
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasourceUrl?: string
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Defaults to stdout
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events
     * log: [
     *   { emit: 'stdout', level: 'query' },
     *   { emit: 'stdout', level: 'info' },
     *   { emit: 'stdout', level: 'warn' }
     *   { emit: 'stdout', level: 'error' }
     * ]
     * ```
     * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
  }
  export type GlobalOmitConfig = {
    user?: UserOmit
    account?: AccountOmit
    session?: SessionOmit
    otp?: OtpOmit
    koasProfile?: KoasProfileOmit
    pasienProfile?: PasienProfileOmit
    fasilitatorProfile?: FasilitatorProfileOmit
    university?: UniversityOmit
    post?: PostOmit
    like?: LikeOmit
    notification?: NotificationOmit
    treatmentType?: TreatmentTypeOmit
    schedule?: ScheduleOmit
    timeslot?: TimeslotOmit
    review?: ReviewOmit
    appointment?: AppointmentOmit
    verificationrequest?: verificationrequestOmit
  }

  /* 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'
    | 'findUniqueOrThrow'
    | 'findMany'
    | 'findFirst'
    | 'findFirstOrThrow'
    | 'create'
    | 'createMany'
    | 'createManyAndReturn'
    | 'update'
    | 'updateMany'
    | 'updateManyAndReturn'
    | 'upsert'
    | 'delete'
    | 'deleteMany'
    | 'executeRaw'
    | 'queryRaw'
    | 'aggregate'
    | 'count'
    | 'runCommandRaw'
    | 'findRaw'
    | 'groupBy'

  /**
   * These options are being passed into the middleware as "params"
   */
  export type MiddlewareParams = {
    model?: ModelName
    action: PrismaAction
    args: any
    dataPath: string[]
    runInTransaction: boolean
  }

  /**
   * The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation
   */
  export type Middleware<T = any> = (
    params: MiddlewareParams,
    next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
  ) => $Utils.JsPromise<T>

  // tested in getLogLevel.test.ts
  export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;

  /**
   * `PrismaClient` proxy available in interactive transactions.
   */
  export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    Account: number
    Like: number
    sender: number
    recipient: number
    Post: number
    Review: number
    sessions: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Account?: boolean | UserCountOutputTypeCountAccountArgs
    Like?: boolean | UserCountOutputTypeCountLikeArgs
    sender?: boolean | UserCountOutputTypeCountSenderArgs
    recipient?: boolean | UserCountOutputTypeCountRecipientArgs
    Post?: boolean | UserCountOutputTypeCountPostArgs
    Review?: boolean | UserCountOutputTypeCountReviewArgs
    sessions?: boolean | UserCountOutputTypeCountSessionsArgs
  }

  // Custom InputTypes
  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserCountOutputType
     */
    select?: UserCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountAccountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountLikeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LikeWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountSenderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountRecipientArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountPostArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PostWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ReviewWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountSessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionWhereInput
  }


  /**
   * Count Type KoasProfileCountOutputType
   */

  export type KoasProfileCountOutputType = {
    Appointment: number
    Notification: number
    Post: number
    Review: number
  }

  export type KoasProfileCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | KoasProfileCountOutputTypeCountAppointmentArgs
    Notification?: boolean | KoasProfileCountOutputTypeCountNotificationArgs
    Post?: boolean | KoasProfileCountOutputTypeCountPostArgs
    Review?: boolean | KoasProfileCountOutputTypeCountReviewArgs
  }

  // Custom InputTypes
  /**
   * KoasProfileCountOutputType without action
   */
  export type KoasProfileCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfileCountOutputType
     */
    select?: KoasProfileCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * KoasProfileCountOutputType without action
   */
  export type KoasProfileCountOutputTypeCountAppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
  }

  /**
   * KoasProfileCountOutputType without action
   */
  export type KoasProfileCountOutputTypeCountNotificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationWhereInput
  }

  /**
   * KoasProfileCountOutputType without action
   */
  export type KoasProfileCountOutputTypeCountPostArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PostWhereInput
  }

  /**
   * KoasProfileCountOutputType without action
   */
  export type KoasProfileCountOutputTypeCountReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ReviewWhereInput
  }


  /**
   * Count Type PasienProfileCountOutputType
   */

  export type PasienProfileCountOutputType = {
    Appointment: number
  }

  export type PasienProfileCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | PasienProfileCountOutputTypeCountAppointmentArgs
  }

  // Custom InputTypes
  /**
   * PasienProfileCountOutputType without action
   */
  export type PasienProfileCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfileCountOutputType
     */
    select?: PasienProfileCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * PasienProfileCountOutputType without action
   */
  export type PasienProfileCountOutputTypeCountAppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
  }


  /**
   * Count Type UniversityCountOutputType
   */

  export type UniversityCountOutputType = {
    koasProfile: number
  }

  export type UniversityCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    koasProfile?: boolean | UniversityCountOutputTypeCountKoasProfileArgs
  }

  // Custom InputTypes
  /**
   * UniversityCountOutputType without action
   */
  export type UniversityCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UniversityCountOutputType
     */
    select?: UniversityCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * UniversityCountOutputType without action
   */
  export type UniversityCountOutputTypeCountKoasProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: KoasProfileWhereInput
  }


  /**
   * Count Type PostCountOutputType
   */

  export type PostCountOutputType = {
    likes: number
    Review: number
    Schedule: number
  }

  export type PostCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | PostCountOutputTypeCountLikesArgs
    Review?: boolean | PostCountOutputTypeCountReviewArgs
    Schedule?: boolean | PostCountOutputTypeCountScheduleArgs
  }

  // Custom InputTypes
  /**
   * PostCountOutputType without action
   */
  export type PostCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PostCountOutputType
     */
    select?: PostCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * PostCountOutputType without action
   */
  export type PostCountOutputTypeCountLikesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LikeWhereInput
  }

  /**
   * PostCountOutputType without action
   */
  export type PostCountOutputTypeCountReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ReviewWhereInput
  }

  /**
   * PostCountOutputType without action
   */
  export type PostCountOutputTypeCountScheduleArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ScheduleWhereInput
  }


  /**
   * Count Type TreatmentTypeCountOutputType
   */

  export type TreatmentTypeCountOutputType = {
    Post: number
  }

  export type TreatmentTypeCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Post?: boolean | TreatmentTypeCountOutputTypeCountPostArgs
  }

  // Custom InputTypes
  /**
   * TreatmentTypeCountOutputType without action
   */
  export type TreatmentTypeCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentTypeCountOutputType
     */
    select?: TreatmentTypeCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * TreatmentTypeCountOutputType without action
   */
  export type TreatmentTypeCountOutputTypeCountPostArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PostWhereInput
  }


  /**
   * Count Type ScheduleCountOutputType
   */

  export type ScheduleCountOutputType = {
    Appointment: number
    timeslot: number
  }

  export type ScheduleCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | ScheduleCountOutputTypeCountAppointmentArgs
    timeslot?: boolean | ScheduleCountOutputTypeCountTimeslotArgs
  }

  // Custom InputTypes
  /**
   * ScheduleCountOutputType without action
   */
  export type ScheduleCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ScheduleCountOutputType
     */
    select?: ScheduleCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * ScheduleCountOutputType without action
   */
  export type ScheduleCountOutputTypeCountAppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
  }

  /**
   * ScheduleCountOutputType without action
   */
  export type ScheduleCountOutputTypeCountTimeslotArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TimeslotWhereInput
  }


  /**
   * Count Type TimeslotCountOutputType
   */

  export type TimeslotCountOutputType = {
    Appointment: number
  }

  export type TimeslotCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | TimeslotCountOutputTypeCountAppointmentArgs
  }

  // Custom InputTypes
  /**
   * TimeslotCountOutputType without action
   */
  export type TimeslotCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TimeslotCountOutputType
     */
    select?: TimeslotCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * TimeslotCountOutputType without action
   */
  export type TimeslotCountOutputTypeCountAppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
  }


  /**
   * Models
   */

  /**
   * Model User
   */

  export type AggregateUser = {
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

  export type UserMinAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    emailVerified: Date | null
    password: string | null
    phone: string | null
    address: string | null
    image: string | null
    role: $Enums.Role | null
    createdAt: Date | null
    updateAt: Date | null
    familyName: string | null
    givenName: string | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    name: string | null
    email: string | null
    emailVerified: Date | null
    password: string | null
    phone: string | null
    address: string | null
    image: string | null
    role: $Enums.Role | null
    createdAt: Date | null
    updateAt: Date | null
    familyName: string | null
    givenName: string | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    name: number
    email: number
    emailVerified: number
    password: number
    phone: number
    address: number
    image: number
    role: number
    createdAt: number
    updateAt: number
    familyName: number
    givenName: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    name?: true
    email?: true
    emailVerified?: true
    password?: true
    phone?: true
    address?: true
    image?: true
    role?: true
    createdAt?: true
    updateAt?: true
    familyName?: true
    givenName?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    name?: true
    email?: true
    emailVerified?: true
    password?: true
    phone?: true
    address?: true
    image?: true
    role?: true
    createdAt?: true
    updateAt?: true
    familyName?: true
    givenName?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    name?: true
    email?: true
    emailVerified?: true
    password?: true
    phone?: true
    address?: true
    image?: true
    role?: true
    createdAt?: true
    updateAt?: true
    familyName?: true
    givenName?: true
    _all?: true
  }

  export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * 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?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@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 | UserCountAggregateInputType
    /**
     * {@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 UserAggregateArgs> = {
        [P in keyof T & keyof AggregateUser]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateUser[P]>
      : GetScalarType<T[P], AggregateUser[P]>
  }




  export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserWhereInput
    orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
    by: UserScalarFieldEnum[] | UserScalarFieldEnum
    having?: UserScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserCountAggregateInputType | true
    _min?: UserMinAggregateInputType
    _max?: UserMaxAggregateInputType
  }

  export type UserGroupByOutputType = {
    id: string
    name: string | null
    email: string | null
    emailVerified: Date | null
    password: string | null
    phone: string | null
    address: string | null
    image: string | null
    role: $Enums.Role | null
    createdAt: Date
    updateAt: Date
    familyName: string | null
    givenName: string | null
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

  type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<UserGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], UserGroupByOutputType[P]>
            : GetScalarType<T[P], UserGroupByOutputType[P]>
        }
      >
    >


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    email?: boolean
    emailVerified?: boolean
    password?: boolean
    phone?: boolean
    address?: boolean
    image?: boolean
    role?: boolean
    createdAt?: boolean
    updateAt?: boolean
    familyName?: boolean
    givenName?: boolean
    Account?: boolean | User$AccountArgs<ExtArgs>
    FasilitatorProfile?: boolean | User$FasilitatorProfileArgs<ExtArgs>
    KoasProfile?: boolean | User$KoasProfileArgs<ExtArgs>
    Like?: boolean | User$LikeArgs<ExtArgs>
    sender?: boolean | User$senderArgs<ExtArgs>
    recipient?: boolean | User$recipientArgs<ExtArgs>
    PasienProfile?: boolean | User$PasienProfileArgs<ExtArgs>
    Post?: boolean | User$PostArgs<ExtArgs>
    Review?: boolean | User$ReviewArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>



  export type UserSelectScalar = {
    id?: boolean
    name?: boolean
    email?: boolean
    emailVerified?: boolean
    password?: boolean
    phone?: boolean
    address?: boolean
    image?: boolean
    role?: boolean
    createdAt?: boolean
    updateAt?: boolean
    familyName?: boolean
    givenName?: boolean
  }

  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "email" | "emailVerified" | "password" | "phone" | "address" | "image" | "role" | "createdAt" | "updateAt" | "familyName" | "givenName", ExtArgs["result"]["user"]>
  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Account?: boolean | User$AccountArgs<ExtArgs>
    FasilitatorProfile?: boolean | User$FasilitatorProfileArgs<ExtArgs>
    KoasProfile?: boolean | User$KoasProfileArgs<ExtArgs>
    Like?: boolean | User$LikeArgs<ExtArgs>
    sender?: boolean | User$senderArgs<ExtArgs>
    recipient?: boolean | User$recipientArgs<ExtArgs>
    PasienProfile?: boolean | User$PasienProfileArgs<ExtArgs>
    Post?: boolean | User$PostArgs<ExtArgs>
    Review?: boolean | User$ReviewArgs<ExtArgs>
    sessions?: boolean | User$sessionsArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      Account: Prisma.$AccountPayload<ExtArgs>[]
      FasilitatorProfile: Prisma.$FasilitatorProfilePayload<ExtArgs> | null
      KoasProfile: Prisma.$KoasProfilePayload<ExtArgs> | null
      Like: Prisma.$LikePayload<ExtArgs>[]
      sender: Prisma.$NotificationPayload<ExtArgs>[]
      recipient: Prisma.$NotificationPayload<ExtArgs>[]
      PasienProfile: Prisma.$PasienProfilePayload<ExtArgs> | null
      Post: Prisma.$PostPayload<ExtArgs>[]
      Review: Prisma.$ReviewPayload<ExtArgs>[]
      sessions: Prisma.$SessionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      email: string | null
      emailVerified: Date | null
      password: string | null
      phone: string | null
      address: string | null
      image: string | null
      role: $Enums.Role | null
      createdAt: Date
      updateAt: Date
      familyName: string | null
      givenName: string | null
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

  type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>

  type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: UserCountAggregateInputType | true
    }

  export interface UserDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } }
    /**
     * Find zero or one User that matches the filter.
     * @param {UserFindUniqueArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends UserFindUniqueArgs>(args: SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one User that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first User that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserFindFirstArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends UserFindFirstArgs>(args?: SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first User that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Users that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserFindManyArgs} 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 UserFindManyArgs>(args?: SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * 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: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Users.
     * @param {UserCreateManyArgs} args - Arguments to create many Users.
     * @example
     * // Create many Users
     * const user = await prisma.user.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends UserCreateManyArgs>(args?: SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * 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: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * 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: SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * 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?: SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Users.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @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: SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<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: SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Users.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserCountArgs} 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<T extends UserCountArgs>(
      args?: Subset<T, UserCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], UserCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserAggregateArgs} 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 UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>

    /**
     * Group by User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserGroupByArgs} 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 UserGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: UserGroupByArgs['orderBy'] }
        : { orderBy?: UserGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the User model
   */
  readonly fields: UserFieldRefs;
  }

  /**
   * 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 interface Prisma__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Account<T extends User$AccountArgs<ExtArgs> = {}>(args?: Subset<T, User$AccountArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    FasilitatorProfile<T extends User$FasilitatorProfileArgs<ExtArgs> = {}>(args?: Subset<T, User$FasilitatorProfileArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    KoasProfile<T extends User$KoasProfileArgs<ExtArgs> = {}>(args?: Subset<T, User$KoasProfileArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    Like<T extends User$LikeArgs<ExtArgs> = {}>(args?: Subset<T, User$LikeArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    sender<T extends User$senderArgs<ExtArgs> = {}>(args?: Subset<T, User$senderArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    recipient<T extends User$recipientArgs<ExtArgs> = {}>(args?: Subset<T, User$recipientArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    PasienProfile<T extends User$PasienProfileArgs<ExtArgs> = {}>(args?: Subset<T, User$PasienProfileArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    Post<T extends User$PostArgs<ExtArgs> = {}>(args?: Subset<T, User$PostArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    Review<T extends User$ReviewArgs<ExtArgs> = {}>(args?: Subset<T, User$ReviewArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    sessions<T extends User$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the User model
   */
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'String'>
    readonly name: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly emailVerified: FieldRef<"User", 'DateTime'>
    readonly password: FieldRef<"User", 'String'>
    readonly phone: FieldRef<"User", 'String'>
    readonly address: FieldRef<"User", 'String'>
    readonly image: FieldRef<"User", 'String'>
    readonly role: FieldRef<"User", 'Role'>
    readonly createdAt: FieldRef<"User", 'DateTime'>
    readonly updateAt: FieldRef<"User", 'DateTime'>
    readonly familyName: FieldRef<"User", 'String'>
    readonly givenName: FieldRef<"User", 'String'>
  }
    

  // Custom InputTypes
  /**
   * User findUnique
   */
  export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findUniqueOrThrow
   */
  export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findFirst
   */
  export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | 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?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@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?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findFirstOrThrow
   */
  export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | 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?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@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?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findMany
   */
  export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | 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?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@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?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

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

  /**
   * User createMany
   */
  export type UserCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Users.
     */
    data: UserCreateManyInput | UserCreateManyInput[]
    skipDuplicates?: boolean
  }

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

  /**
   * User updateMany
   */
  export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to update.
     */
    limit?: number
  }

  /**
   * User upsert
   */
  export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | 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<UserCreateInput, UserUncheckedCreateInput>
    /**
     * In case the User was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
  }

  /**
   * User delete
   */
  export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter which User to delete.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User deleteMany
   */
  export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Users to delete
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to delete.
     */
    limit?: number
  }

  /**
   * User.Account
   */
  export type User$AccountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    cursor?: AccountWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * User.FasilitatorProfile
   */
  export type User$FasilitatorProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    where?: FasilitatorProfileWhereInput
  }

  /**
   * User.KoasProfile
   */
  export type User$KoasProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    where?: KoasProfileWhereInput
  }

  /**
   * User.Like
   */
  export type User$LikeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    where?: LikeWhereInput
    orderBy?: LikeOrderByWithRelationInput | LikeOrderByWithRelationInput[]
    cursor?: LikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LikeScalarFieldEnum | LikeScalarFieldEnum[]
  }

  /**
   * User.sender
   */
  export type User$senderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    cursor?: NotificationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * User.recipient
   */
  export type User$recipientArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    cursor?: NotificationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * User.PasienProfile
   */
  export type User$PasienProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    where?: PasienProfileWhereInput
  }

  /**
   * User.Post
   */
  export type User$PostArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
    where?: PostWhereInput
    orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    cursor?: PostWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PostScalarFieldEnum | PostScalarFieldEnum[]
  }

  /**
   * User.Review
   */
  export type User$ReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    where?: ReviewWhereInput
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    cursor?: ReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ReviewScalarFieldEnum | ReviewScalarFieldEnum[]
  }

  /**
   * User.sessions
   */
  export type User$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    where?: SessionWhereInput
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    cursor?: SessionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * User without action
   */
  export type UserDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
  }


  /**
   * Model Account
   */

  export type AggregateAccount = {
    _count: AccountCountAggregateOutputType | null
    _avg: AccountAvgAggregateOutputType | null
    _sum: AccountSumAggregateOutputType | null
    _min: AccountMinAggregateOutputType | null
    _max: AccountMaxAggregateOutputType | null
  }

  export type AccountAvgAggregateOutputType = {
    expires_at: number | null
  }

  export type AccountSumAggregateOutputType = {
    expires_at: number | null
  }

  export type AccountMinAggregateOutputType = {
    type: string | null
    provider: string | null
    scope: string | null
    access_token: string | null
    expires_at: number | null
    id_token: string | null
    providerAccountId: string | null
    refresh_token: string | null
    token_type: string | null
    userId: string | null
    id: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AccountMaxAggregateOutputType = {
    type: string | null
    provider: string | null
    scope: string | null
    access_token: string | null
    expires_at: number | null
    id_token: string | null
    providerAccountId: string | null
    refresh_token: string | null
    token_type: string | null
    userId: string | null
    id: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AccountCountAggregateOutputType = {
    type: number
    provider: number
    scope: number
    access_token: number
    expires_at: number
    id_token: number
    providerAccountId: number
    refresh_token: number
    token_type: number
    userId: number
    id: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type AccountAvgAggregateInputType = {
    expires_at?: true
  }

  export type AccountSumAggregateInputType = {
    expires_at?: true
  }

  export type AccountMinAggregateInputType = {
    type?: true
    provider?: true
    scope?: true
    access_token?: true
    expires_at?: true
    id_token?: true
    providerAccountId?: true
    refresh_token?: true
    token_type?: true
    userId?: true
    id?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AccountMaxAggregateInputType = {
    type?: true
    provider?: true
    scope?: true
    access_token?: true
    expires_at?: true
    id_token?: true
    providerAccountId?: true
    refresh_token?: true
    token_type?: true
    userId?: true
    id?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AccountCountAggregateInputType = {
    type?: true
    provider?: true
    scope?: true
    access_token?: true
    expires_at?: true
    id_token?: true
    providerAccountId?: true
    refresh_token?: true
    token_type?: true
    userId?: true
    id?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type AccountAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Account to aggregate.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Accounts
    **/
    _count?: true | AccountCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AccountAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AccountSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AccountMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AccountMaxAggregateInputType
  }

  export type GetAccountAggregateType<T extends AccountAggregateArgs> = {
        [P in keyof T & keyof AggregateAccount]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAccount[P]>
      : GetScalarType<T[P], AggregateAccount[P]>
  }




  export type AccountGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithAggregationInput | AccountOrderByWithAggregationInput[]
    by: AccountScalarFieldEnum[] | AccountScalarFieldEnum
    having?: AccountScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AccountCountAggregateInputType | true
    _avg?: AccountAvgAggregateInputType
    _sum?: AccountSumAggregateInputType
    _min?: AccountMinAggregateInputType
    _max?: AccountMaxAggregateInputType
  }

  export type AccountGroupByOutputType = {
    type: string | null
    provider: string
    scope: string | null
    access_token: string | null
    expires_at: number | null
    id_token: string | null
    providerAccountId: string
    refresh_token: string | null
    token_type: string | null
    userId: string
    id: string
    createdAt: Date
    updatedAt: Date
    _count: AccountCountAggregateOutputType | null
    _avg: AccountAvgAggregateOutputType | null
    _sum: AccountSumAggregateOutputType | null
    _min: AccountMinAggregateOutputType | null
    _max: AccountMaxAggregateOutputType | null
  }

  type GetAccountGroupByPayload<T extends AccountGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<AccountGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof AccountGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], AccountGroupByOutputType[P]>
            : GetScalarType<T[P], AccountGroupByOutputType[P]>
        }
      >
    >


  export type AccountSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    type?: boolean
    provider?: boolean
    scope?: boolean
    access_token?: boolean
    expires_at?: boolean
    id_token?: boolean
    providerAccountId?: boolean
    refresh_token?: boolean
    token_type?: boolean
    userId?: boolean
    id?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>



  export type AccountSelectScalar = {
    type?: boolean
    provider?: boolean
    scope?: boolean
    access_token?: boolean
    expires_at?: boolean
    id_token?: boolean
    providerAccountId?: boolean
    refresh_token?: boolean
    token_type?: boolean
    userId?: boolean
    id?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type AccountOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"type" | "provider" | "scope" | "access_token" | "expires_at" | "id_token" | "providerAccountId" | "refresh_token" | "token_type" | "userId" | "id" | "createdAt" | "updatedAt", ExtArgs["result"]["account"]>
  export type AccountInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AccountPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Account"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      type: string | null
      provider: string
      scope: string | null
      access_token: string | null
      expires_at: number | null
      id_token: string | null
      providerAccountId: string
      refresh_token: string | null
      token_type: string | null
      userId: string
      id: string
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["account"]>
    composites: {}
  }

  type AccountGetPayload<S extends boolean | null | undefined | AccountDefaultArgs> = $Result.GetResult<Prisma.$AccountPayload, S>

  type AccountCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AccountFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AccountCountAggregateInputType | true
    }

  export interface AccountDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Account'], meta: { name: 'Account' } }
    /**
     * Find zero or one Account that matches the filter.
     * @param {AccountFindUniqueArgs} args - Arguments to find a Account
     * @example
     * // Get one Account
     * const account = await prisma.account.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends AccountFindUniqueArgs>(args: SelectSubset<T, AccountFindUniqueArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Account that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {AccountFindUniqueOrThrowArgs} args - Arguments to find a Account
     * @example
     * // Get one Account
     * const account = await prisma.account.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends AccountFindUniqueOrThrowArgs>(args: SelectSubset<T, AccountFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Account that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountFindFirstArgs} args - Arguments to find a Account
     * @example
     * // Get one Account
     * const account = await prisma.account.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AccountFindFirstArgs>(args?: SelectSubset<T, AccountFindFirstArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Account that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountFindFirstOrThrowArgs} args - Arguments to find a Account
     * @example
     * // Get one Account
     * const account = await prisma.account.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AccountFindFirstOrThrowArgs>(args?: SelectSubset<T, AccountFindFirstOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Accounts that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Accounts
     * const accounts = await prisma.account.findMany()
     * 
     * // Get first 10 Accounts
     * const accounts = await prisma.account.findMany({ take: 10 })
     * 
     * // Only select the `type`
     * const accountWithTypeOnly = await prisma.account.findMany({ select: { type: true } })
     * 
     */
    findMany<T extends AccountFindManyArgs>(args?: SelectSubset<T, AccountFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Account.
     * @param {AccountCreateArgs} args - Arguments to create a Account.
     * @example
     * // Create one Account
     * const Account = await prisma.account.create({
     *   data: {
     *     // ... data to create a Account
     *   }
     * })
     * 
     */
    create<T extends AccountCreateArgs>(args: SelectSubset<T, AccountCreateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Accounts.
     * @param {AccountCreateManyArgs} args - Arguments to create many Accounts.
     * @example
     * // Create many Accounts
     * const account = await prisma.account.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends AccountCreateManyArgs>(args?: SelectSubset<T, AccountCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Account.
     * @param {AccountDeleteArgs} args - Arguments to delete one Account.
     * @example
     * // Delete one Account
     * const Account = await prisma.account.delete({
     *   where: {
     *     // ... filter to delete one Account
     *   }
     * })
     * 
     */
    delete<T extends AccountDeleteArgs>(args: SelectSubset<T, AccountDeleteArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Account.
     * @param {AccountUpdateArgs} args - Arguments to update one Account.
     * @example
     * // Update one Account
     * const account = await prisma.account.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AccountUpdateArgs>(args: SelectSubset<T, AccountUpdateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Accounts.
     * @param {AccountDeleteManyArgs} args - Arguments to filter Accounts to delete.
     * @example
     * // Delete a few Accounts
     * const { count } = await prisma.account.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends AccountDeleteManyArgs>(args?: SelectSubset<T, AccountDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Accounts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Accounts
     * const account = await prisma.account.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends AccountUpdateManyArgs>(args: SelectSubset<T, AccountUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Account.
     * @param {AccountUpsertArgs} args - Arguments to update or create a Account.
     * @example
     * // Update or create a Account
     * const account = await prisma.account.upsert({
     *   create: {
     *     // ... data to create a Account
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Account we want to update
     *   }
     * })
     */
    upsert<T extends AccountUpsertArgs>(args: SelectSubset<T, AccountUpsertArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Accounts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountCountArgs} args - Arguments to filter Accounts to count.
     * @example
     * // Count the number of Accounts
     * const count = await prisma.account.count({
     *   where: {
     *     // ... the filter for the Accounts we want to count
     *   }
     * })
    **/
    count<T extends AccountCountArgs>(
      args?: Subset<T, AccountCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], AccountCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Account.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountAggregateArgs} 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 AccountAggregateArgs>(args: Subset<T, AccountAggregateArgs>): Prisma.PrismaPromise<GetAccountAggregateType<T>>

    /**
     * Group by Account.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountGroupByArgs} 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 AccountGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AccountGroupByArgs['orderBy'] }
        : { orderBy?: AccountGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, AccountGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccountGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Account model
   */
  readonly fields: AccountFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Account.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__AccountClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Account model
   */
  interface AccountFieldRefs {
    readonly type: FieldRef<"Account", 'String'>
    readonly provider: FieldRef<"Account", 'String'>
    readonly scope: FieldRef<"Account", 'String'>
    readonly access_token: FieldRef<"Account", 'String'>
    readonly expires_at: FieldRef<"Account", 'Int'>
    readonly id_token: FieldRef<"Account", 'String'>
    readonly providerAccountId: FieldRef<"Account", 'String'>
    readonly refresh_token: FieldRef<"Account", 'String'>
    readonly token_type: FieldRef<"Account", 'String'>
    readonly userId: FieldRef<"Account", 'String'>
    readonly id: FieldRef<"Account", 'String'>
    readonly createdAt: FieldRef<"Account", 'DateTime'>
    readonly updatedAt: FieldRef<"Account", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Account findUnique
   */
  export type AccountFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account findUniqueOrThrow
   */
  export type AccountFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account findFirst
   */
  export type AccountFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accounts.
     */
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account findFirstOrThrow
   */
  export type AccountFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accounts.
     */
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account findMany
   */
  export type AccountFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Accounts to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account create
   */
  export type AccountCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The data needed to create a Account.
     */
    data: XOR<AccountCreateInput, AccountUncheckedCreateInput>
  }

  /**
   * Account createMany
   */
  export type AccountCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Accounts.
     */
    data: AccountCreateManyInput | AccountCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Account update
   */
  export type AccountUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The data needed to update a Account.
     */
    data: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
    /**
     * Choose, which Account to update.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account updateMany
   */
  export type AccountUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Accounts.
     */
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
    /**
     * Filter which Accounts to update
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to update.
     */
    limit?: number
  }

  /**
   * Account upsert
   */
  export type AccountUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The filter to search for the Account to update in case it exists.
     */
    where: AccountWhereUniqueInput
    /**
     * In case the Account found by the `where` argument doesn't exist, create a new Account with this data.
     */
    create: XOR<AccountCreateInput, AccountUncheckedCreateInput>
    /**
     * In case the Account was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
  }

  /**
   * Account delete
   */
  export type AccountDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter which Account to delete.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account deleteMany
   */
  export type AccountDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Accounts to delete
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to delete.
     */
    limit?: number
  }

  /**
   * Account without action
   */
  export type AccountDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
  }


  /**
   * Model Session
   */

  export type AggregateSession = {
    _count: SessionCountAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  export type SessionMinAggregateOutputType = {
    id: string | null
    expires: Date | null
    sessionToken: string | null
    userId: string | null
    accessToken: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SessionMaxAggregateOutputType = {
    id: string | null
    expires: Date | null
    sessionToken: string | null
    userId: string | null
    accessToken: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SessionCountAggregateOutputType = {
    id: number
    expires: number
    sessionToken: number
    userId: number
    accessToken: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type SessionMinAggregateInputType = {
    id?: true
    expires?: true
    sessionToken?: true
    userId?: true
    accessToken?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SessionMaxAggregateInputType = {
    id?: true
    expires?: true
    sessionToken?: true
    userId?: true
    accessToken?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SessionCountAggregateInputType = {
    id?: true
    expires?: true
    sessionToken?: true
    userId?: true
    accessToken?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type SessionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Session to aggregate.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Sessions
    **/
    _count?: true | SessionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SessionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SessionMaxAggregateInputType
  }

  export type GetSessionAggregateType<T extends SessionAggregateArgs> = {
        [P in keyof T & keyof AggregateSession]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSession[P]>
      : GetScalarType<T[P], AggregateSession[P]>
  }




  export type SessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SessionWhereInput
    orderBy?: SessionOrderByWithAggregationInput | SessionOrderByWithAggregationInput[]
    by: SessionScalarFieldEnum[] | SessionScalarFieldEnum
    having?: SessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SessionCountAggregateInputType | true
    _min?: SessionMinAggregateInputType
    _max?: SessionMaxAggregateInputType
  }

  export type SessionGroupByOutputType = {
    id: string
    expires: Date
    sessionToken: string
    userId: string | null
    accessToken: string | null
    createdAt: Date
    updatedAt: Date
    _count: SessionCountAggregateOutputType | null
    _min: SessionMinAggregateOutputType | null
    _max: SessionMaxAggregateOutputType | null
  }

  type GetSessionGroupByPayload<T extends SessionGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<SessionGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof SessionGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], SessionGroupByOutputType[P]>
            : GetScalarType<T[P], SessionGroupByOutputType[P]>
        }
      >
    >


  export type SessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    expires?: boolean
    sessionToken?: boolean
    userId?: boolean
    accessToken?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    user?: boolean | Session$userArgs<ExtArgs>
  }, ExtArgs["result"]["session"]>



  export type SessionSelectScalar = {
    id?: boolean
    expires?: boolean
    sessionToken?: boolean
    userId?: boolean
    accessToken?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type SessionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "expires" | "sessionToken" | "userId" | "accessToken" | "createdAt" | "updatedAt", ExtArgs["result"]["session"]>
  export type SessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | Session$userArgs<ExtArgs>
  }

  export type $SessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Session"
    objects: {
      user: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      expires: Date
      sessionToken: string
      userId: string | null
      accessToken: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["session"]>
    composites: {}
  }

  type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = $Result.GetResult<Prisma.$SessionPayload, S>

  type SessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: SessionCountAggregateInputType | true
    }

  export interface SessionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Session'], meta: { name: 'Session' } }
    /**
     * Find zero or one Session that matches the filter.
     * @param {SessionFindUniqueArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends SessionFindUniqueArgs>(args: SelectSubset<T, SessionFindUniqueArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Session that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {SessionFindUniqueOrThrowArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends SessionFindUniqueOrThrowArgs>(args: SelectSubset<T, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Session that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionFindFirstArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SessionFindFirstArgs>(args?: SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Session that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionFindFirstOrThrowArgs} args - Arguments to find a Session
     * @example
     * // Get one Session
     * const session = await prisma.session.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Sessions that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Sessions
     * const sessions = await prisma.session.findMany()
     * 
     * // Get first 10 Sessions
     * const sessions = await prisma.session.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends SessionFindManyArgs>(args?: SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Session.
     * @param {SessionCreateArgs} args - Arguments to create a Session.
     * @example
     * // Create one Session
     * const Session = await prisma.session.create({
     *   data: {
     *     // ... data to create a Session
     *   }
     * })
     * 
     */
    create<T extends SessionCreateArgs>(args: SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Sessions.
     * @param {SessionCreateManyArgs} args - Arguments to create many Sessions.
     * @example
     * // Create many Sessions
     * const session = await prisma.session.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends SessionCreateManyArgs>(args?: SelectSubset<T, SessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Session.
     * @param {SessionDeleteArgs} args - Arguments to delete one Session.
     * @example
     * // Delete one Session
     * const Session = await prisma.session.delete({
     *   where: {
     *     // ... filter to delete one Session
     *   }
     * })
     * 
     */
    delete<T extends SessionDeleteArgs>(args: SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Session.
     * @param {SessionUpdateArgs} args - Arguments to update one Session.
     * @example
     * // Update one Session
     * const session = await prisma.session.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SessionUpdateArgs>(args: SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Sessions.
     * @param {SessionDeleteManyArgs} args - Arguments to filter Sessions to delete.
     * @example
     * // Delete a few Sessions
     * const { count } = await prisma.session.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends SessionDeleteManyArgs>(args?: SelectSubset<T, SessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Sessions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Sessions
     * const session = await prisma.session.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends SessionUpdateManyArgs>(args: SelectSubset<T, SessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Session.
     * @param {SessionUpsertArgs} args - Arguments to update or create a Session.
     * @example
     * // Update or create a Session
     * const session = await prisma.session.upsert({
     *   create: {
     *     // ... data to create a Session
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Session we want to update
     *   }
     * })
     */
    upsert<T extends SessionUpsertArgs>(args: SelectSubset<T, SessionUpsertArgs<ExtArgs>>): Prisma__SessionClient<$Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Sessions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionCountArgs} args - Arguments to filter Sessions to count.
     * @example
     * // Count the number of Sessions
     * const count = await prisma.session.count({
     *   where: {
     *     // ... the filter for the Sessions we want to count
     *   }
     * })
    **/
    count<T extends SessionCountArgs>(
      args?: Subset<T, SessionCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], SessionCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionAggregateArgs} 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 SessionAggregateArgs>(args: Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>>

    /**
     * Group by Session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SessionGroupByArgs} 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 SessionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SessionGroupByArgs['orderBy'] }
        : { orderBy?: SessionGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Session model
   */
  readonly fields: SessionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Session.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__SessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends Session$userArgs<ExtArgs> = {}>(args?: Subset<T, Session$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Session model
   */
  interface SessionFieldRefs {
    readonly id: FieldRef<"Session", 'String'>
    readonly expires: FieldRef<"Session", 'DateTime'>
    readonly sessionToken: FieldRef<"Session", 'String'>
    readonly userId: FieldRef<"Session", 'String'>
    readonly accessToken: FieldRef<"Session", 'String'>
    readonly createdAt: FieldRef<"Session", 'DateTime'>
    readonly updatedAt: FieldRef<"Session", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Session findUnique
   */
  export type SessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session findUniqueOrThrow
   */
  export type SessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session findFirst
   */
  export type SessionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sessions.
     */
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session findFirstOrThrow
   */
  export type SessionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Session to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Sessions.
     */
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session findMany
   */
  export type SessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter, which Sessions to fetch.
     */
    where?: SessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Sessions to fetch.
     */
    orderBy?: SessionOrderByWithRelationInput | SessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Sessions.
     */
    cursor?: SessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Sessions 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` Sessions.
     */
    skip?: number
    distinct?: SessionScalarFieldEnum | SessionScalarFieldEnum[]
  }

  /**
   * Session create
   */
  export type SessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The data needed to create a Session.
     */
    data: XOR<SessionCreateInput, SessionUncheckedCreateInput>
  }

  /**
   * Session createMany
   */
  export type SessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Sessions.
     */
    data: SessionCreateManyInput | SessionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Session update
   */
  export type SessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The data needed to update a Session.
     */
    data: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
    /**
     * Choose, which Session to update.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session updateMany
   */
  export type SessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Sessions.
     */
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyInput>
    /**
     * Filter which Sessions to update
     */
    where?: SessionWhereInput
    /**
     * Limit how many Sessions to update.
     */
    limit?: number
  }

  /**
   * Session upsert
   */
  export type SessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * The filter to search for the Session to update in case it exists.
     */
    where: SessionWhereUniqueInput
    /**
     * In case the Session found by the `where` argument doesn't exist, create a new Session with this data.
     */
    create: XOR<SessionCreateInput, SessionUncheckedCreateInput>
    /**
     * In case the Session was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SessionUpdateInput, SessionUncheckedUpdateInput>
  }

  /**
   * Session delete
   */
  export type SessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
    /**
     * Filter which Session to delete.
     */
    where: SessionWhereUniqueInput
  }

  /**
   * Session deleteMany
   */
  export type SessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Sessions to delete
     */
    where?: SessionWhereInput
    /**
     * Limit how many Sessions to delete.
     */
    limit?: number
  }

  /**
   * Session.user
   */
  export type Session$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
  }

  /**
   * Session without action
   */
  export type SessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Session
     */
    select?: SessionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Session
     */
    omit?: SessionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SessionInclude<ExtArgs> | null
  }


  /**
   * Model Otp
   */

  export type AggregateOtp = {
    _count: OtpCountAggregateOutputType | null
    _min: OtpMinAggregateOutputType | null
    _max: OtpMaxAggregateOutputType | null
  }

  export type OtpMinAggregateOutputType = {
    id: string | null
    email: string | null
    otp: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type OtpMaxAggregateOutputType = {
    id: string | null
    email: string | null
    otp: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type OtpCountAggregateOutputType = {
    id: number
    email: number
    otp: number
    expires: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type OtpMinAggregateInputType = {
    id?: true
    email?: true
    otp?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
  }

  export type OtpMaxAggregateInputType = {
    id?: true
    email?: true
    otp?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
  }

  export type OtpCountAggregateInputType = {
    id?: true
    email?: true
    otp?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type OtpAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Otp to aggregate.
     */
    where?: OtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Otps to fetch.
     */
    orderBy?: OtpOrderByWithRelationInput | OtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: OtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Otps 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` Otps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Otps
    **/
    _count?: true | OtpCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: OtpMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: OtpMaxAggregateInputType
  }

  export type GetOtpAggregateType<T extends OtpAggregateArgs> = {
        [P in keyof T & keyof AggregateOtp]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateOtp[P]>
      : GetScalarType<T[P], AggregateOtp[P]>
  }




  export type OtpGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OtpWhereInput
    orderBy?: OtpOrderByWithAggregationInput | OtpOrderByWithAggregationInput[]
    by: OtpScalarFieldEnum[] | OtpScalarFieldEnum
    having?: OtpScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OtpCountAggregateInputType | true
    _min?: OtpMinAggregateInputType
    _max?: OtpMaxAggregateInputType
  }

  export type OtpGroupByOutputType = {
    id: string
    email: string
    otp: string
    expires: Date
    createdAt: Date
    updatedAt: Date
    _count: OtpCountAggregateOutputType | null
    _min: OtpMinAggregateOutputType | null
    _max: OtpMaxAggregateOutputType | null
  }

  type GetOtpGroupByPayload<T extends OtpGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<OtpGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof OtpGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], OtpGroupByOutputType[P]>
            : GetScalarType<T[P], OtpGroupByOutputType[P]>
        }
      >
    >


  export type OtpSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    otp?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["otp"]>



  export type OtpSelectScalar = {
    id?: boolean
    email?: boolean
    otp?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type OtpOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "email" | "otp" | "expires" | "createdAt" | "updatedAt", ExtArgs["result"]["otp"]>

  export type $OtpPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Otp"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      email: string
      otp: string
      expires: Date
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["otp"]>
    composites: {}
  }

  type OtpGetPayload<S extends boolean | null | undefined | OtpDefaultArgs> = $Result.GetResult<Prisma.$OtpPayload, S>

  type OtpCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<OtpFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: OtpCountAggregateInputType | true
    }

  export interface OtpDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Otp'], meta: { name: 'Otp' } }
    /**
     * Find zero or one Otp that matches the filter.
     * @param {OtpFindUniqueArgs} args - Arguments to find a Otp
     * @example
     * // Get one Otp
     * const otp = await prisma.otp.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends OtpFindUniqueArgs>(args: SelectSubset<T, OtpFindUniqueArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Otp that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {OtpFindUniqueOrThrowArgs} args - Arguments to find a Otp
     * @example
     * // Get one Otp
     * const otp = await prisma.otp.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends OtpFindUniqueOrThrowArgs>(args: SelectSubset<T, OtpFindUniqueOrThrowArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Otp that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpFindFirstArgs} args - Arguments to find a Otp
     * @example
     * // Get one Otp
     * const otp = await prisma.otp.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends OtpFindFirstArgs>(args?: SelectSubset<T, OtpFindFirstArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Otp that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpFindFirstOrThrowArgs} args - Arguments to find a Otp
     * @example
     * // Get one Otp
     * const otp = await prisma.otp.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends OtpFindFirstOrThrowArgs>(args?: SelectSubset<T, OtpFindFirstOrThrowArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Otps that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Otps
     * const otps = await prisma.otp.findMany()
     * 
     * // Get first 10 Otps
     * const otps = await prisma.otp.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const otpWithIdOnly = await prisma.otp.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends OtpFindManyArgs>(args?: SelectSubset<T, OtpFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Otp.
     * @param {OtpCreateArgs} args - Arguments to create a Otp.
     * @example
     * // Create one Otp
     * const Otp = await prisma.otp.create({
     *   data: {
     *     // ... data to create a Otp
     *   }
     * })
     * 
     */
    create<T extends OtpCreateArgs>(args: SelectSubset<T, OtpCreateArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Otps.
     * @param {OtpCreateManyArgs} args - Arguments to create many Otps.
     * @example
     * // Create many Otps
     * const otp = await prisma.otp.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends OtpCreateManyArgs>(args?: SelectSubset<T, OtpCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Otp.
     * @param {OtpDeleteArgs} args - Arguments to delete one Otp.
     * @example
     * // Delete one Otp
     * const Otp = await prisma.otp.delete({
     *   where: {
     *     // ... filter to delete one Otp
     *   }
     * })
     * 
     */
    delete<T extends OtpDeleteArgs>(args: SelectSubset<T, OtpDeleteArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Otp.
     * @param {OtpUpdateArgs} args - Arguments to update one Otp.
     * @example
     * // Update one Otp
     * const otp = await prisma.otp.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends OtpUpdateArgs>(args: SelectSubset<T, OtpUpdateArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Otps.
     * @param {OtpDeleteManyArgs} args - Arguments to filter Otps to delete.
     * @example
     * // Delete a few Otps
     * const { count } = await prisma.otp.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends OtpDeleteManyArgs>(args?: SelectSubset<T, OtpDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Otps.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Otps
     * const otp = await prisma.otp.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends OtpUpdateManyArgs>(args: SelectSubset<T, OtpUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Otp.
     * @param {OtpUpsertArgs} args - Arguments to update or create a Otp.
     * @example
     * // Update or create a Otp
     * const otp = await prisma.otp.upsert({
     *   create: {
     *     // ... data to create a Otp
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Otp we want to update
     *   }
     * })
     */
    upsert<T extends OtpUpsertArgs>(args: SelectSubset<T, OtpUpsertArgs<ExtArgs>>): Prisma__OtpClient<$Result.GetResult<Prisma.$OtpPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Otps.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpCountArgs} args - Arguments to filter Otps to count.
     * @example
     * // Count the number of Otps
     * const count = await prisma.otp.count({
     *   where: {
     *     // ... the filter for the Otps we want to count
     *   }
     * })
    **/
    count<T extends OtpCountArgs>(
      args?: Subset<T, OtpCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], OtpCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Otp.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpAggregateArgs} 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 OtpAggregateArgs>(args: Subset<T, OtpAggregateArgs>): Prisma.PrismaPromise<GetOtpAggregateType<T>>

    /**
     * Group by Otp.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OtpGroupByArgs} 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 OtpGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: OtpGroupByArgs['orderBy'] }
        : { orderBy?: OtpGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, OtpGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetOtpGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Otp model
   */
  readonly fields: OtpFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Otp.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__OtpClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Otp model
   */
  interface OtpFieldRefs {
    readonly id: FieldRef<"Otp", 'String'>
    readonly email: FieldRef<"Otp", 'String'>
    readonly otp: FieldRef<"Otp", 'String'>
    readonly expires: FieldRef<"Otp", 'DateTime'>
    readonly createdAt: FieldRef<"Otp", 'DateTime'>
    readonly updatedAt: FieldRef<"Otp", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Otp findUnique
   */
  export type OtpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * Filter, which Otp to fetch.
     */
    where: OtpWhereUniqueInput
  }

  /**
   * Otp findUniqueOrThrow
   */
  export type OtpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * Filter, which Otp to fetch.
     */
    where: OtpWhereUniqueInput
  }

  /**
   * Otp findFirst
   */
  export type OtpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * Filter, which Otp to fetch.
     */
    where?: OtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Otps to fetch.
     */
    orderBy?: OtpOrderByWithRelationInput | OtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Otps.
     */
    cursor?: OtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Otps 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` Otps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Otps.
     */
    distinct?: OtpScalarFieldEnum | OtpScalarFieldEnum[]
  }

  /**
   * Otp findFirstOrThrow
   */
  export type OtpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * Filter, which Otp to fetch.
     */
    where?: OtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Otps to fetch.
     */
    orderBy?: OtpOrderByWithRelationInput | OtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Otps.
     */
    cursor?: OtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Otps 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` Otps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Otps.
     */
    distinct?: OtpScalarFieldEnum | OtpScalarFieldEnum[]
  }

  /**
   * Otp findMany
   */
  export type OtpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * Filter, which Otps to fetch.
     */
    where?: OtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Otps to fetch.
     */
    orderBy?: OtpOrderByWithRelationInput | OtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Otps.
     */
    cursor?: OtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Otps 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` Otps.
     */
    skip?: number
    distinct?: OtpScalarFieldEnum | OtpScalarFieldEnum[]
  }

  /**
   * Otp create
   */
  export type OtpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * The data needed to create a Otp.
     */
    data: XOR<OtpCreateInput, OtpUncheckedCreateInput>
  }

  /**
   * Otp createMany
   */
  export type OtpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Otps.
     */
    data: OtpCreateManyInput | OtpCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Otp update
   */
  export type OtpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * The data needed to update a Otp.
     */
    data: XOR<OtpUpdateInput, OtpUncheckedUpdateInput>
    /**
     * Choose, which Otp to update.
     */
    where: OtpWhereUniqueInput
  }

  /**
   * Otp updateMany
   */
  export type OtpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Otps.
     */
    data: XOR<OtpUpdateManyMutationInput, OtpUncheckedUpdateManyInput>
    /**
     * Filter which Otps to update
     */
    where?: OtpWhereInput
    /**
     * Limit how many Otps to update.
     */
    limit?: number
  }

  /**
   * Otp upsert
   */
  export type OtpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * The filter to search for the Otp to update in case it exists.
     */
    where: OtpWhereUniqueInput
    /**
     * In case the Otp found by the `where` argument doesn't exist, create a new Otp with this data.
     */
    create: XOR<OtpCreateInput, OtpUncheckedCreateInput>
    /**
     * In case the Otp was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OtpUpdateInput, OtpUncheckedUpdateInput>
  }

  /**
   * Otp delete
   */
  export type OtpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
    /**
     * Filter which Otp to delete.
     */
    where: OtpWhereUniqueInput
  }

  /**
   * Otp deleteMany
   */
  export type OtpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Otps to delete
     */
    where?: OtpWhereInput
    /**
     * Limit how many Otps to delete.
     */
    limit?: number
  }

  /**
   * Otp without action
   */
  export type OtpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Otp
     */
    select?: OtpSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Otp
     */
    omit?: OtpOmit<ExtArgs> | null
  }


  /**
   * Model KoasProfile
   */

  export type AggregateKoasProfile = {
    _count: KoasProfileCountAggregateOutputType | null
    _avg: KoasProfileAvgAggregateOutputType | null
    _sum: KoasProfileSumAggregateOutputType | null
    _min: KoasProfileMinAggregateOutputType | null
    _max: KoasProfileMaxAggregateOutputType | null
  }

  export type KoasProfileAvgAggregateOutputType = {
    experience: number | null
  }

  export type KoasProfileSumAggregateOutputType = {
    experience: number | null
  }

  export type KoasProfileMinAggregateOutputType = {
    id: string | null
    userId: string | null
    koasNumber: string | null
    age: string | null
    gender: string | null
    departement: string | null
    university: string | null
    bio: string | null
    whatsappLink: string | null
    status: $Enums.StatusKoas | null
    createdAt: Date | null
    updateAt: Date | null
    universityId: string | null
    experience: number | null
  }

  export type KoasProfileMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    koasNumber: string | null
    age: string | null
    gender: string | null
    departement: string | null
    university: string | null
    bio: string | null
    whatsappLink: string | null
    status: $Enums.StatusKoas | null
    createdAt: Date | null
    updateAt: Date | null
    universityId: string | null
    experience: number | null
  }

  export type KoasProfileCountAggregateOutputType = {
    id: number
    userId: number
    koasNumber: number
    age: number
    gender: number
    departement: number
    university: number
    bio: number
    whatsappLink: number
    status: number
    createdAt: number
    updateAt: number
    universityId: number
    experience: number
    _all: number
  }


  export type KoasProfileAvgAggregateInputType = {
    experience?: true
  }

  export type KoasProfileSumAggregateInputType = {
    experience?: true
  }

  export type KoasProfileMinAggregateInputType = {
    id?: true
    userId?: true
    koasNumber?: true
    age?: true
    gender?: true
    departement?: true
    university?: true
    bio?: true
    whatsappLink?: true
    status?: true
    createdAt?: true
    updateAt?: true
    universityId?: true
    experience?: true
  }

  export type KoasProfileMaxAggregateInputType = {
    id?: true
    userId?: true
    koasNumber?: true
    age?: true
    gender?: true
    departement?: true
    university?: true
    bio?: true
    whatsappLink?: true
    status?: true
    createdAt?: true
    updateAt?: true
    universityId?: true
    experience?: true
  }

  export type KoasProfileCountAggregateInputType = {
    id?: true
    userId?: true
    koasNumber?: true
    age?: true
    gender?: true
    departement?: true
    university?: true
    bio?: true
    whatsappLink?: true
    status?: true
    createdAt?: true
    updateAt?: true
    universityId?: true
    experience?: true
    _all?: true
  }

  export type KoasProfileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which KoasProfile to aggregate.
     */
    where?: KoasProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KoasProfiles to fetch.
     */
    orderBy?: KoasProfileOrderByWithRelationInput | KoasProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: KoasProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KoasProfiles 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` KoasProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned KoasProfiles
    **/
    _count?: true | KoasProfileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: KoasProfileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: KoasProfileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: KoasProfileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: KoasProfileMaxAggregateInputType
  }

  export type GetKoasProfileAggregateType<T extends KoasProfileAggregateArgs> = {
        [P in keyof T & keyof AggregateKoasProfile]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateKoasProfile[P]>
      : GetScalarType<T[P], AggregateKoasProfile[P]>
  }




  export type KoasProfileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: KoasProfileWhereInput
    orderBy?: KoasProfileOrderByWithAggregationInput | KoasProfileOrderByWithAggregationInput[]
    by: KoasProfileScalarFieldEnum[] | KoasProfileScalarFieldEnum
    having?: KoasProfileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: KoasProfileCountAggregateInputType | true
    _avg?: KoasProfileAvgAggregateInputType
    _sum?: KoasProfileSumAggregateInputType
    _min?: KoasProfileMinAggregateInputType
    _max?: KoasProfileMaxAggregateInputType
  }

  export type KoasProfileGroupByOutputType = {
    id: string
    userId: string
    koasNumber: string | null
    age: string | null
    gender: string | null
    departement: string | null
    university: string | null
    bio: string | null
    whatsappLink: string | null
    status: $Enums.StatusKoas
    createdAt: Date
    updateAt: Date
    universityId: string | null
    experience: number | null
    _count: KoasProfileCountAggregateOutputType | null
    _avg: KoasProfileAvgAggregateOutputType | null
    _sum: KoasProfileSumAggregateOutputType | null
    _min: KoasProfileMinAggregateOutputType | null
    _max: KoasProfileMaxAggregateOutputType | null
  }

  type GetKoasProfileGroupByPayload<T extends KoasProfileGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<KoasProfileGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof KoasProfileGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], KoasProfileGroupByOutputType[P]>
            : GetScalarType<T[P], KoasProfileGroupByOutputType[P]>
        }
      >
    >


  export type KoasProfileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    koasNumber?: boolean
    age?: boolean
    gender?: boolean
    departement?: boolean
    university?: boolean
    bio?: boolean
    whatsappLink?: boolean
    status?: boolean
    createdAt?: boolean
    updateAt?: boolean
    universityId?: boolean
    experience?: boolean
    Appointment?: boolean | KoasProfile$AppointmentArgs<ExtArgs>
    University?: boolean | KoasProfile$UniversityArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    Notification?: boolean | KoasProfile$NotificationArgs<ExtArgs>
    Post?: boolean | KoasProfile$PostArgs<ExtArgs>
    Review?: boolean | KoasProfile$ReviewArgs<ExtArgs>
    _count?: boolean | KoasProfileCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["koasProfile"]>



  export type KoasProfileSelectScalar = {
    id?: boolean
    userId?: boolean
    koasNumber?: boolean
    age?: boolean
    gender?: boolean
    departement?: boolean
    university?: boolean
    bio?: boolean
    whatsappLink?: boolean
    status?: boolean
    createdAt?: boolean
    updateAt?: boolean
    universityId?: boolean
    experience?: boolean
  }

  export type KoasProfileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "koasNumber" | "age" | "gender" | "departement" | "university" | "bio" | "whatsappLink" | "status" | "createdAt" | "updateAt" | "universityId" | "experience", ExtArgs["result"]["koasProfile"]>
  export type KoasProfileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | KoasProfile$AppointmentArgs<ExtArgs>
    University?: boolean | KoasProfile$UniversityArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    Notification?: boolean | KoasProfile$NotificationArgs<ExtArgs>
    Post?: boolean | KoasProfile$PostArgs<ExtArgs>
    Review?: boolean | KoasProfile$ReviewArgs<ExtArgs>
    _count?: boolean | KoasProfileCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $KoasProfilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "KoasProfile"
    objects: {
      Appointment: Prisma.$AppointmentPayload<ExtArgs>[]
      University: Prisma.$UniversityPayload<ExtArgs> | null
      user: Prisma.$UserPayload<ExtArgs>
      Notification: Prisma.$NotificationPayload<ExtArgs>[]
      Post: Prisma.$PostPayload<ExtArgs>[]
      Review: Prisma.$ReviewPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      koasNumber: string | null
      age: string | null
      gender: string | null
      departement: string | null
      university: string | null
      bio: string | null
      whatsappLink: string | null
      status: $Enums.StatusKoas
      createdAt: Date
      updateAt: Date
      universityId: string | null
      experience: number | null
    }, ExtArgs["result"]["koasProfile"]>
    composites: {}
  }

  type KoasProfileGetPayload<S extends boolean | null | undefined | KoasProfileDefaultArgs> = $Result.GetResult<Prisma.$KoasProfilePayload, S>

  type KoasProfileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<KoasProfileFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: KoasProfileCountAggregateInputType | true
    }

  export interface KoasProfileDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['KoasProfile'], meta: { name: 'KoasProfile' } }
    /**
     * Find zero or one KoasProfile that matches the filter.
     * @param {KoasProfileFindUniqueArgs} args - Arguments to find a KoasProfile
     * @example
     * // Get one KoasProfile
     * const koasProfile = await prisma.koasProfile.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends KoasProfileFindUniqueArgs>(args: SelectSubset<T, KoasProfileFindUniqueArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one KoasProfile that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {KoasProfileFindUniqueOrThrowArgs} args - Arguments to find a KoasProfile
     * @example
     * // Get one KoasProfile
     * const koasProfile = await prisma.koasProfile.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends KoasProfileFindUniqueOrThrowArgs>(args: SelectSubset<T, KoasProfileFindUniqueOrThrowArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first KoasProfile that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileFindFirstArgs} args - Arguments to find a KoasProfile
     * @example
     * // Get one KoasProfile
     * const koasProfile = await prisma.koasProfile.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends KoasProfileFindFirstArgs>(args?: SelectSubset<T, KoasProfileFindFirstArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first KoasProfile that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileFindFirstOrThrowArgs} args - Arguments to find a KoasProfile
     * @example
     * // Get one KoasProfile
     * const koasProfile = await prisma.koasProfile.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends KoasProfileFindFirstOrThrowArgs>(args?: SelectSubset<T, KoasProfileFindFirstOrThrowArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more KoasProfiles that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all KoasProfiles
     * const koasProfiles = await prisma.koasProfile.findMany()
     * 
     * // Get first 10 KoasProfiles
     * const koasProfiles = await prisma.koasProfile.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const koasProfileWithIdOnly = await prisma.koasProfile.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends KoasProfileFindManyArgs>(args?: SelectSubset<T, KoasProfileFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a KoasProfile.
     * @param {KoasProfileCreateArgs} args - Arguments to create a KoasProfile.
     * @example
     * // Create one KoasProfile
     * const KoasProfile = await prisma.koasProfile.create({
     *   data: {
     *     // ... data to create a KoasProfile
     *   }
     * })
     * 
     */
    create<T extends KoasProfileCreateArgs>(args: SelectSubset<T, KoasProfileCreateArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many KoasProfiles.
     * @param {KoasProfileCreateManyArgs} args - Arguments to create many KoasProfiles.
     * @example
     * // Create many KoasProfiles
     * const koasProfile = await prisma.koasProfile.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends KoasProfileCreateManyArgs>(args?: SelectSubset<T, KoasProfileCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a KoasProfile.
     * @param {KoasProfileDeleteArgs} args - Arguments to delete one KoasProfile.
     * @example
     * // Delete one KoasProfile
     * const KoasProfile = await prisma.koasProfile.delete({
     *   where: {
     *     // ... filter to delete one KoasProfile
     *   }
     * })
     * 
     */
    delete<T extends KoasProfileDeleteArgs>(args: SelectSubset<T, KoasProfileDeleteArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one KoasProfile.
     * @param {KoasProfileUpdateArgs} args - Arguments to update one KoasProfile.
     * @example
     * // Update one KoasProfile
     * const koasProfile = await prisma.koasProfile.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends KoasProfileUpdateArgs>(args: SelectSubset<T, KoasProfileUpdateArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more KoasProfiles.
     * @param {KoasProfileDeleteManyArgs} args - Arguments to filter KoasProfiles to delete.
     * @example
     * // Delete a few KoasProfiles
     * const { count } = await prisma.koasProfile.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends KoasProfileDeleteManyArgs>(args?: SelectSubset<T, KoasProfileDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more KoasProfiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many KoasProfiles
     * const koasProfile = await prisma.koasProfile.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends KoasProfileUpdateManyArgs>(args: SelectSubset<T, KoasProfileUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one KoasProfile.
     * @param {KoasProfileUpsertArgs} args - Arguments to update or create a KoasProfile.
     * @example
     * // Update or create a KoasProfile
     * const koasProfile = await prisma.koasProfile.upsert({
     *   create: {
     *     // ... data to create a KoasProfile
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the KoasProfile we want to update
     *   }
     * })
     */
    upsert<T extends KoasProfileUpsertArgs>(args: SelectSubset<T, KoasProfileUpsertArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of KoasProfiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileCountArgs} args - Arguments to filter KoasProfiles to count.
     * @example
     * // Count the number of KoasProfiles
     * const count = await prisma.koasProfile.count({
     *   where: {
     *     // ... the filter for the KoasProfiles we want to count
     *   }
     * })
    **/
    count<T extends KoasProfileCountArgs>(
      args?: Subset<T, KoasProfileCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], KoasProfileCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a KoasProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileAggregateArgs} 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 KoasProfileAggregateArgs>(args: Subset<T, KoasProfileAggregateArgs>): Prisma.PrismaPromise<GetKoasProfileAggregateType<T>>

    /**
     * Group by KoasProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {KoasProfileGroupByArgs} 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 KoasProfileGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: KoasProfileGroupByArgs['orderBy'] }
        : { orderBy?: KoasProfileGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, KoasProfileGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetKoasProfileGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the KoasProfile model
   */
  readonly fields: KoasProfileFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for KoasProfile.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__KoasProfileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Appointment<T extends KoasProfile$AppointmentArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfile$AppointmentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    University<T extends KoasProfile$UniversityArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfile$UniversityArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    Notification<T extends KoasProfile$NotificationArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfile$NotificationArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    Post<T extends KoasProfile$PostArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfile$PostArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    Review<T extends KoasProfile$ReviewArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfile$ReviewArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the KoasProfile model
   */
  interface KoasProfileFieldRefs {
    readonly id: FieldRef<"KoasProfile", 'String'>
    readonly userId: FieldRef<"KoasProfile", 'String'>
    readonly koasNumber: FieldRef<"KoasProfile", 'String'>
    readonly age: FieldRef<"KoasProfile", 'String'>
    readonly gender: FieldRef<"KoasProfile", 'String'>
    readonly departement: FieldRef<"KoasProfile", 'String'>
    readonly university: FieldRef<"KoasProfile", 'String'>
    readonly bio: FieldRef<"KoasProfile", 'String'>
    readonly whatsappLink: FieldRef<"KoasProfile", 'String'>
    readonly status: FieldRef<"KoasProfile", 'StatusKoas'>
    readonly createdAt: FieldRef<"KoasProfile", 'DateTime'>
    readonly updateAt: FieldRef<"KoasProfile", 'DateTime'>
    readonly universityId: FieldRef<"KoasProfile", 'String'>
    readonly experience: FieldRef<"KoasProfile", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * KoasProfile findUnique
   */
  export type KoasProfileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * Filter, which KoasProfile to fetch.
     */
    where: KoasProfileWhereUniqueInput
  }

  /**
   * KoasProfile findUniqueOrThrow
   */
  export type KoasProfileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * Filter, which KoasProfile to fetch.
     */
    where: KoasProfileWhereUniqueInput
  }

  /**
   * KoasProfile findFirst
   */
  export type KoasProfileFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * Filter, which KoasProfile to fetch.
     */
    where?: KoasProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KoasProfiles to fetch.
     */
    orderBy?: KoasProfileOrderByWithRelationInput | KoasProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for KoasProfiles.
     */
    cursor?: KoasProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KoasProfiles 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` KoasProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of KoasProfiles.
     */
    distinct?: KoasProfileScalarFieldEnum | KoasProfileScalarFieldEnum[]
  }

  /**
   * KoasProfile findFirstOrThrow
   */
  export type KoasProfileFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * Filter, which KoasProfile to fetch.
     */
    where?: KoasProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KoasProfiles to fetch.
     */
    orderBy?: KoasProfileOrderByWithRelationInput | KoasProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for KoasProfiles.
     */
    cursor?: KoasProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KoasProfiles 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` KoasProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of KoasProfiles.
     */
    distinct?: KoasProfileScalarFieldEnum | KoasProfileScalarFieldEnum[]
  }

  /**
   * KoasProfile findMany
   */
  export type KoasProfileFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * Filter, which KoasProfiles to fetch.
     */
    where?: KoasProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of KoasProfiles to fetch.
     */
    orderBy?: KoasProfileOrderByWithRelationInput | KoasProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing KoasProfiles.
     */
    cursor?: KoasProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` KoasProfiles 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` KoasProfiles.
     */
    skip?: number
    distinct?: KoasProfileScalarFieldEnum | KoasProfileScalarFieldEnum[]
  }

  /**
   * KoasProfile create
   */
  export type KoasProfileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * The data needed to create a KoasProfile.
     */
    data: XOR<KoasProfileCreateInput, KoasProfileUncheckedCreateInput>
  }

  /**
   * KoasProfile createMany
   */
  export type KoasProfileCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many KoasProfiles.
     */
    data: KoasProfileCreateManyInput | KoasProfileCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * KoasProfile update
   */
  export type KoasProfileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * The data needed to update a KoasProfile.
     */
    data: XOR<KoasProfileUpdateInput, KoasProfileUncheckedUpdateInput>
    /**
     * Choose, which KoasProfile to update.
     */
    where: KoasProfileWhereUniqueInput
  }

  /**
   * KoasProfile updateMany
   */
  export type KoasProfileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update KoasProfiles.
     */
    data: XOR<KoasProfileUpdateManyMutationInput, KoasProfileUncheckedUpdateManyInput>
    /**
     * Filter which KoasProfiles to update
     */
    where?: KoasProfileWhereInput
    /**
     * Limit how many KoasProfiles to update.
     */
    limit?: number
  }

  /**
   * KoasProfile upsert
   */
  export type KoasProfileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * The filter to search for the KoasProfile to update in case it exists.
     */
    where: KoasProfileWhereUniqueInput
    /**
     * In case the KoasProfile found by the `where` argument doesn't exist, create a new KoasProfile with this data.
     */
    create: XOR<KoasProfileCreateInput, KoasProfileUncheckedCreateInput>
    /**
     * In case the KoasProfile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<KoasProfileUpdateInput, KoasProfileUncheckedUpdateInput>
  }

  /**
   * KoasProfile delete
   */
  export type KoasProfileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    /**
     * Filter which KoasProfile to delete.
     */
    where: KoasProfileWhereUniqueInput
  }

  /**
   * KoasProfile deleteMany
   */
  export type KoasProfileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which KoasProfiles to delete
     */
    where?: KoasProfileWhereInput
    /**
     * Limit how many KoasProfiles to delete.
     */
    limit?: number
  }

  /**
   * KoasProfile.Appointment
   */
  export type KoasProfile$AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    where?: AppointmentWhereInput
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    cursor?: AppointmentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * KoasProfile.University
   */
  export type KoasProfile$UniversityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    where?: UniversityWhereInput
  }

  /**
   * KoasProfile.Notification
   */
  export type KoasProfile$NotificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    cursor?: NotificationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * KoasProfile.Post
   */
  export type KoasProfile$PostArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
    where?: PostWhereInput
    orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    cursor?: PostWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PostScalarFieldEnum | PostScalarFieldEnum[]
  }

  /**
   * KoasProfile.Review
   */
  export type KoasProfile$ReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    where?: ReviewWhereInput
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    cursor?: ReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ReviewScalarFieldEnum | ReviewScalarFieldEnum[]
  }

  /**
   * KoasProfile without action
   */
  export type KoasProfileDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
  }


  /**
   * Model PasienProfile
   */

  export type AggregatePasienProfile = {
    _count: PasienProfileCountAggregateOutputType | null
    _min: PasienProfileMinAggregateOutputType | null
    _max: PasienProfileMaxAggregateOutputType | null
  }

  export type PasienProfileMinAggregateOutputType = {
    id: string | null
    userId: string | null
    age: string | null
    gender: string | null
    bio: string | null
    createdAt: Date | null
    updateAt: Date | null
  }

  export type PasienProfileMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    age: string | null
    gender: string | null
    bio: string | null
    createdAt: Date | null
    updateAt: Date | null
  }

  export type PasienProfileCountAggregateOutputType = {
    id: number
    userId: number
    age: number
    gender: number
    bio: number
    createdAt: number
    updateAt: number
    _all: number
  }


  export type PasienProfileMinAggregateInputType = {
    id?: true
    userId?: true
    age?: true
    gender?: true
    bio?: true
    createdAt?: true
    updateAt?: true
  }

  export type PasienProfileMaxAggregateInputType = {
    id?: true
    userId?: true
    age?: true
    gender?: true
    bio?: true
    createdAt?: true
    updateAt?: true
  }

  export type PasienProfileCountAggregateInputType = {
    id?: true
    userId?: true
    age?: true
    gender?: true
    bio?: true
    createdAt?: true
    updateAt?: true
    _all?: true
  }

  export type PasienProfileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PasienProfile to aggregate.
     */
    where?: PasienProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PasienProfiles to fetch.
     */
    orderBy?: PasienProfileOrderByWithRelationInput | PasienProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PasienProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PasienProfiles 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` PasienProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PasienProfiles
    **/
    _count?: true | PasienProfileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PasienProfileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PasienProfileMaxAggregateInputType
  }

  export type GetPasienProfileAggregateType<T extends PasienProfileAggregateArgs> = {
        [P in keyof T & keyof AggregatePasienProfile]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePasienProfile[P]>
      : GetScalarType<T[P], AggregatePasienProfile[P]>
  }




  export type PasienProfileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PasienProfileWhereInput
    orderBy?: PasienProfileOrderByWithAggregationInput | PasienProfileOrderByWithAggregationInput[]
    by: PasienProfileScalarFieldEnum[] | PasienProfileScalarFieldEnum
    having?: PasienProfileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PasienProfileCountAggregateInputType | true
    _min?: PasienProfileMinAggregateInputType
    _max?: PasienProfileMaxAggregateInputType
  }

  export type PasienProfileGroupByOutputType = {
    id: string
    userId: string
    age: string | null
    gender: string | null
    bio: string | null
    createdAt: Date
    updateAt: Date
    _count: PasienProfileCountAggregateOutputType | null
    _min: PasienProfileMinAggregateOutputType | null
    _max: PasienProfileMaxAggregateOutputType | null
  }

  type GetPasienProfileGroupByPayload<T extends PasienProfileGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PasienProfileGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PasienProfileGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PasienProfileGroupByOutputType[P]>
            : GetScalarType<T[P], PasienProfileGroupByOutputType[P]>
        }
      >
    >


  export type PasienProfileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    age?: boolean
    gender?: boolean
    bio?: boolean
    createdAt?: boolean
    updateAt?: boolean
    Appointment?: boolean | PasienProfile$AppointmentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    _count?: boolean | PasienProfileCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["pasienProfile"]>



  export type PasienProfileSelectScalar = {
    id?: boolean
    userId?: boolean
    age?: boolean
    gender?: boolean
    bio?: boolean
    createdAt?: boolean
    updateAt?: boolean
  }

  export type PasienProfileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "age" | "gender" | "bio" | "createdAt" | "updateAt", ExtArgs["result"]["pasienProfile"]>
  export type PasienProfileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | PasienProfile$AppointmentArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    _count?: boolean | PasienProfileCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $PasienProfilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PasienProfile"
    objects: {
      Appointment: Prisma.$AppointmentPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      age: string | null
      gender: string | null
      bio: string | null
      createdAt: Date
      updateAt: Date
    }, ExtArgs["result"]["pasienProfile"]>
    composites: {}
  }

  type PasienProfileGetPayload<S extends boolean | null | undefined | PasienProfileDefaultArgs> = $Result.GetResult<Prisma.$PasienProfilePayload, S>

  type PasienProfileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PasienProfileFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PasienProfileCountAggregateInputType | true
    }

  export interface PasienProfileDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['PasienProfile'], meta: { name: 'PasienProfile' } }
    /**
     * Find zero or one PasienProfile that matches the filter.
     * @param {PasienProfileFindUniqueArgs} args - Arguments to find a PasienProfile
     * @example
     * // Get one PasienProfile
     * const pasienProfile = await prisma.pasienProfile.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PasienProfileFindUniqueArgs>(args: SelectSubset<T, PasienProfileFindUniqueArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one PasienProfile that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PasienProfileFindUniqueOrThrowArgs} args - Arguments to find a PasienProfile
     * @example
     * // Get one PasienProfile
     * const pasienProfile = await prisma.pasienProfile.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PasienProfileFindUniqueOrThrowArgs>(args: SelectSubset<T, PasienProfileFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first PasienProfile that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileFindFirstArgs} args - Arguments to find a PasienProfile
     * @example
     * // Get one PasienProfile
     * const pasienProfile = await prisma.pasienProfile.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PasienProfileFindFirstArgs>(args?: SelectSubset<T, PasienProfileFindFirstArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first PasienProfile that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileFindFirstOrThrowArgs} args - Arguments to find a PasienProfile
     * @example
     * // Get one PasienProfile
     * const pasienProfile = await prisma.pasienProfile.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PasienProfileFindFirstOrThrowArgs>(args?: SelectSubset<T, PasienProfileFindFirstOrThrowArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more PasienProfiles that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all PasienProfiles
     * const pasienProfiles = await prisma.pasienProfile.findMany()
     * 
     * // Get first 10 PasienProfiles
     * const pasienProfiles = await prisma.pasienProfile.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const pasienProfileWithIdOnly = await prisma.pasienProfile.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PasienProfileFindManyArgs>(args?: SelectSubset<T, PasienProfileFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a PasienProfile.
     * @param {PasienProfileCreateArgs} args - Arguments to create a PasienProfile.
     * @example
     * // Create one PasienProfile
     * const PasienProfile = await prisma.pasienProfile.create({
     *   data: {
     *     // ... data to create a PasienProfile
     *   }
     * })
     * 
     */
    create<T extends PasienProfileCreateArgs>(args: SelectSubset<T, PasienProfileCreateArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many PasienProfiles.
     * @param {PasienProfileCreateManyArgs} args - Arguments to create many PasienProfiles.
     * @example
     * // Create many PasienProfiles
     * const pasienProfile = await prisma.pasienProfile.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PasienProfileCreateManyArgs>(args?: SelectSubset<T, PasienProfileCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a PasienProfile.
     * @param {PasienProfileDeleteArgs} args - Arguments to delete one PasienProfile.
     * @example
     * // Delete one PasienProfile
     * const PasienProfile = await prisma.pasienProfile.delete({
     *   where: {
     *     // ... filter to delete one PasienProfile
     *   }
     * })
     * 
     */
    delete<T extends PasienProfileDeleteArgs>(args: SelectSubset<T, PasienProfileDeleteArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one PasienProfile.
     * @param {PasienProfileUpdateArgs} args - Arguments to update one PasienProfile.
     * @example
     * // Update one PasienProfile
     * const pasienProfile = await prisma.pasienProfile.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PasienProfileUpdateArgs>(args: SelectSubset<T, PasienProfileUpdateArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more PasienProfiles.
     * @param {PasienProfileDeleteManyArgs} args - Arguments to filter PasienProfiles to delete.
     * @example
     * // Delete a few PasienProfiles
     * const { count } = await prisma.pasienProfile.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends PasienProfileDeleteManyArgs>(args?: SelectSubset<T, PasienProfileDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more PasienProfiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many PasienProfiles
     * const pasienProfile = await prisma.pasienProfile.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends PasienProfileUpdateManyArgs>(args: SelectSubset<T, PasienProfileUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one PasienProfile.
     * @param {PasienProfileUpsertArgs} args - Arguments to update or create a PasienProfile.
     * @example
     * // Update or create a PasienProfile
     * const pasienProfile = await prisma.pasienProfile.upsert({
     *   create: {
     *     // ... data to create a PasienProfile
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the PasienProfile we want to update
     *   }
     * })
     */
    upsert<T extends PasienProfileUpsertArgs>(args: SelectSubset<T, PasienProfileUpsertArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of PasienProfiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileCountArgs} args - Arguments to filter PasienProfiles to count.
     * @example
     * // Count the number of PasienProfiles
     * const count = await prisma.pasienProfile.count({
     *   where: {
     *     // ... the filter for the PasienProfiles we want to count
     *   }
     * })
    **/
    count<T extends PasienProfileCountArgs>(
      args?: Subset<T, PasienProfileCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PasienProfileCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a PasienProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileAggregateArgs} 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 PasienProfileAggregateArgs>(args: Subset<T, PasienProfileAggregateArgs>): Prisma.PrismaPromise<GetPasienProfileAggregateType<T>>

    /**
     * Group by PasienProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PasienProfileGroupByArgs} 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 PasienProfileGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PasienProfileGroupByArgs['orderBy'] }
        : { orderBy?: PasienProfileGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, PasienProfileGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPasienProfileGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the PasienProfile model
   */
  readonly fields: PasienProfileFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for PasienProfile.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__PasienProfileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Appointment<T extends PasienProfile$AppointmentArgs<ExtArgs> = {}>(args?: Subset<T, PasienProfile$AppointmentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the PasienProfile model
   */
  interface PasienProfileFieldRefs {
    readonly id: FieldRef<"PasienProfile", 'String'>
    readonly userId: FieldRef<"PasienProfile", 'String'>
    readonly age: FieldRef<"PasienProfile", 'String'>
    readonly gender: FieldRef<"PasienProfile", 'String'>
    readonly bio: FieldRef<"PasienProfile", 'String'>
    readonly createdAt: FieldRef<"PasienProfile", 'DateTime'>
    readonly updateAt: FieldRef<"PasienProfile", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * PasienProfile findUnique
   */
  export type PasienProfileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * Filter, which PasienProfile to fetch.
     */
    where: PasienProfileWhereUniqueInput
  }

  /**
   * PasienProfile findUniqueOrThrow
   */
  export type PasienProfileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * Filter, which PasienProfile to fetch.
     */
    where: PasienProfileWhereUniqueInput
  }

  /**
   * PasienProfile findFirst
   */
  export type PasienProfileFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * Filter, which PasienProfile to fetch.
     */
    where?: PasienProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PasienProfiles to fetch.
     */
    orderBy?: PasienProfileOrderByWithRelationInput | PasienProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PasienProfiles.
     */
    cursor?: PasienProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PasienProfiles 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` PasienProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PasienProfiles.
     */
    distinct?: PasienProfileScalarFieldEnum | PasienProfileScalarFieldEnum[]
  }

  /**
   * PasienProfile findFirstOrThrow
   */
  export type PasienProfileFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * Filter, which PasienProfile to fetch.
     */
    where?: PasienProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PasienProfiles to fetch.
     */
    orderBy?: PasienProfileOrderByWithRelationInput | PasienProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PasienProfiles.
     */
    cursor?: PasienProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PasienProfiles 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` PasienProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PasienProfiles.
     */
    distinct?: PasienProfileScalarFieldEnum | PasienProfileScalarFieldEnum[]
  }

  /**
   * PasienProfile findMany
   */
  export type PasienProfileFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * Filter, which PasienProfiles to fetch.
     */
    where?: PasienProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PasienProfiles to fetch.
     */
    orderBy?: PasienProfileOrderByWithRelationInput | PasienProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PasienProfiles.
     */
    cursor?: PasienProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PasienProfiles 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` PasienProfiles.
     */
    skip?: number
    distinct?: PasienProfileScalarFieldEnum | PasienProfileScalarFieldEnum[]
  }

  /**
   * PasienProfile create
   */
  export type PasienProfileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * The data needed to create a PasienProfile.
     */
    data: XOR<PasienProfileCreateInput, PasienProfileUncheckedCreateInput>
  }

  /**
   * PasienProfile createMany
   */
  export type PasienProfileCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PasienProfiles.
     */
    data: PasienProfileCreateManyInput | PasienProfileCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * PasienProfile update
   */
  export type PasienProfileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * The data needed to update a PasienProfile.
     */
    data: XOR<PasienProfileUpdateInput, PasienProfileUncheckedUpdateInput>
    /**
     * Choose, which PasienProfile to update.
     */
    where: PasienProfileWhereUniqueInput
  }

  /**
   * PasienProfile updateMany
   */
  export type PasienProfileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PasienProfiles.
     */
    data: XOR<PasienProfileUpdateManyMutationInput, PasienProfileUncheckedUpdateManyInput>
    /**
     * Filter which PasienProfiles to update
     */
    where?: PasienProfileWhereInput
    /**
     * Limit how many PasienProfiles to update.
     */
    limit?: number
  }

  /**
   * PasienProfile upsert
   */
  export type PasienProfileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * The filter to search for the PasienProfile to update in case it exists.
     */
    where: PasienProfileWhereUniqueInput
    /**
     * In case the PasienProfile found by the `where` argument doesn't exist, create a new PasienProfile with this data.
     */
    create: XOR<PasienProfileCreateInput, PasienProfileUncheckedCreateInput>
    /**
     * In case the PasienProfile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PasienProfileUpdateInput, PasienProfileUncheckedUpdateInput>
  }

  /**
   * PasienProfile delete
   */
  export type PasienProfileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
    /**
     * Filter which PasienProfile to delete.
     */
    where: PasienProfileWhereUniqueInput
  }

  /**
   * PasienProfile deleteMany
   */
  export type PasienProfileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PasienProfiles to delete
     */
    where?: PasienProfileWhereInput
    /**
     * Limit how many PasienProfiles to delete.
     */
    limit?: number
  }

  /**
   * PasienProfile.Appointment
   */
  export type PasienProfile$AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    where?: AppointmentWhereInput
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    cursor?: AppointmentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * PasienProfile without action
   */
  export type PasienProfileDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PasienProfile
     */
    select?: PasienProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the PasienProfile
     */
    omit?: PasienProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PasienProfileInclude<ExtArgs> | null
  }


  /**
   * Model FasilitatorProfile
   */

  export type AggregateFasilitatorProfile = {
    _count: FasilitatorProfileCountAggregateOutputType | null
    _min: FasilitatorProfileMinAggregateOutputType | null
    _max: FasilitatorProfileMaxAggregateOutputType | null
  }

  export type FasilitatorProfileMinAggregateOutputType = {
    id: string | null
    userId: string | null
    university: string | null
  }

  export type FasilitatorProfileMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    university: string | null
  }

  export type FasilitatorProfileCountAggregateOutputType = {
    id: number
    userId: number
    university: number
    _all: number
  }


  export type FasilitatorProfileMinAggregateInputType = {
    id?: true
    userId?: true
    university?: true
  }

  export type FasilitatorProfileMaxAggregateInputType = {
    id?: true
    userId?: true
    university?: true
  }

  export type FasilitatorProfileCountAggregateInputType = {
    id?: true
    userId?: true
    university?: true
    _all?: true
  }

  export type FasilitatorProfileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FasilitatorProfile to aggregate.
     */
    where?: FasilitatorProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FasilitatorProfiles to fetch.
     */
    orderBy?: FasilitatorProfileOrderByWithRelationInput | FasilitatorProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FasilitatorProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FasilitatorProfiles 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` FasilitatorProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned FasilitatorProfiles
    **/
    _count?: true | FasilitatorProfileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FasilitatorProfileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FasilitatorProfileMaxAggregateInputType
  }

  export type GetFasilitatorProfileAggregateType<T extends FasilitatorProfileAggregateArgs> = {
        [P in keyof T & keyof AggregateFasilitatorProfile]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateFasilitatorProfile[P]>
      : GetScalarType<T[P], AggregateFasilitatorProfile[P]>
  }




  export type FasilitatorProfileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FasilitatorProfileWhereInput
    orderBy?: FasilitatorProfileOrderByWithAggregationInput | FasilitatorProfileOrderByWithAggregationInput[]
    by: FasilitatorProfileScalarFieldEnum[] | FasilitatorProfileScalarFieldEnum
    having?: FasilitatorProfileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FasilitatorProfileCountAggregateInputType | true
    _min?: FasilitatorProfileMinAggregateInputType
    _max?: FasilitatorProfileMaxAggregateInputType
  }

  export type FasilitatorProfileGroupByOutputType = {
    id: string
    userId: string
    university: string | null
    _count: FasilitatorProfileCountAggregateOutputType | null
    _min: FasilitatorProfileMinAggregateOutputType | null
    _max: FasilitatorProfileMaxAggregateOutputType | null
  }

  type GetFasilitatorProfileGroupByPayload<T extends FasilitatorProfileGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<FasilitatorProfileGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof FasilitatorProfileGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], FasilitatorProfileGroupByOutputType[P]>
            : GetScalarType<T[P], FasilitatorProfileGroupByOutputType[P]>
        }
      >
    >


  export type FasilitatorProfileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    university?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["fasilitatorProfile"]>



  export type FasilitatorProfileSelectScalar = {
    id?: boolean
    userId?: boolean
    university?: boolean
  }

  export type FasilitatorProfileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "university", ExtArgs["result"]["fasilitatorProfile"]>
  export type FasilitatorProfileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $FasilitatorProfilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "FasilitatorProfile"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      university: string | null
    }, ExtArgs["result"]["fasilitatorProfile"]>
    composites: {}
  }

  type FasilitatorProfileGetPayload<S extends boolean | null | undefined | FasilitatorProfileDefaultArgs> = $Result.GetResult<Prisma.$FasilitatorProfilePayload, S>

  type FasilitatorProfileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<FasilitatorProfileFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: FasilitatorProfileCountAggregateInputType | true
    }

  export interface FasilitatorProfileDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['FasilitatorProfile'], meta: { name: 'FasilitatorProfile' } }
    /**
     * Find zero or one FasilitatorProfile that matches the filter.
     * @param {FasilitatorProfileFindUniqueArgs} args - Arguments to find a FasilitatorProfile
     * @example
     * // Get one FasilitatorProfile
     * const fasilitatorProfile = await prisma.fasilitatorProfile.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends FasilitatorProfileFindUniqueArgs>(args: SelectSubset<T, FasilitatorProfileFindUniqueArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one FasilitatorProfile that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {FasilitatorProfileFindUniqueOrThrowArgs} args - Arguments to find a FasilitatorProfile
     * @example
     * // Get one FasilitatorProfile
     * const fasilitatorProfile = await prisma.fasilitatorProfile.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends FasilitatorProfileFindUniqueOrThrowArgs>(args: SelectSubset<T, FasilitatorProfileFindUniqueOrThrowArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first FasilitatorProfile that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileFindFirstArgs} args - Arguments to find a FasilitatorProfile
     * @example
     * // Get one FasilitatorProfile
     * const fasilitatorProfile = await prisma.fasilitatorProfile.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends FasilitatorProfileFindFirstArgs>(args?: SelectSubset<T, FasilitatorProfileFindFirstArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first FasilitatorProfile that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileFindFirstOrThrowArgs} args - Arguments to find a FasilitatorProfile
     * @example
     * // Get one FasilitatorProfile
     * const fasilitatorProfile = await prisma.fasilitatorProfile.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends FasilitatorProfileFindFirstOrThrowArgs>(args?: SelectSubset<T, FasilitatorProfileFindFirstOrThrowArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more FasilitatorProfiles that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all FasilitatorProfiles
     * const fasilitatorProfiles = await prisma.fasilitatorProfile.findMany()
     * 
     * // Get first 10 FasilitatorProfiles
     * const fasilitatorProfiles = await prisma.fasilitatorProfile.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const fasilitatorProfileWithIdOnly = await prisma.fasilitatorProfile.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends FasilitatorProfileFindManyArgs>(args?: SelectSubset<T, FasilitatorProfileFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a FasilitatorProfile.
     * @param {FasilitatorProfileCreateArgs} args - Arguments to create a FasilitatorProfile.
     * @example
     * // Create one FasilitatorProfile
     * const FasilitatorProfile = await prisma.fasilitatorProfile.create({
     *   data: {
     *     // ... data to create a FasilitatorProfile
     *   }
     * })
     * 
     */
    create<T extends FasilitatorProfileCreateArgs>(args: SelectSubset<T, FasilitatorProfileCreateArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many FasilitatorProfiles.
     * @param {FasilitatorProfileCreateManyArgs} args - Arguments to create many FasilitatorProfiles.
     * @example
     * // Create many FasilitatorProfiles
     * const fasilitatorProfile = await prisma.fasilitatorProfile.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends FasilitatorProfileCreateManyArgs>(args?: SelectSubset<T, FasilitatorProfileCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a FasilitatorProfile.
     * @param {FasilitatorProfileDeleteArgs} args - Arguments to delete one FasilitatorProfile.
     * @example
     * // Delete one FasilitatorProfile
     * const FasilitatorProfile = await prisma.fasilitatorProfile.delete({
     *   where: {
     *     // ... filter to delete one FasilitatorProfile
     *   }
     * })
     * 
     */
    delete<T extends FasilitatorProfileDeleteArgs>(args: SelectSubset<T, FasilitatorProfileDeleteArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one FasilitatorProfile.
     * @param {FasilitatorProfileUpdateArgs} args - Arguments to update one FasilitatorProfile.
     * @example
     * // Update one FasilitatorProfile
     * const fasilitatorProfile = await prisma.fasilitatorProfile.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends FasilitatorProfileUpdateArgs>(args: SelectSubset<T, FasilitatorProfileUpdateArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more FasilitatorProfiles.
     * @param {FasilitatorProfileDeleteManyArgs} args - Arguments to filter FasilitatorProfiles to delete.
     * @example
     * // Delete a few FasilitatorProfiles
     * const { count } = await prisma.fasilitatorProfile.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends FasilitatorProfileDeleteManyArgs>(args?: SelectSubset<T, FasilitatorProfileDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more FasilitatorProfiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many FasilitatorProfiles
     * const fasilitatorProfile = await prisma.fasilitatorProfile.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends FasilitatorProfileUpdateManyArgs>(args: SelectSubset<T, FasilitatorProfileUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one FasilitatorProfile.
     * @param {FasilitatorProfileUpsertArgs} args - Arguments to update or create a FasilitatorProfile.
     * @example
     * // Update or create a FasilitatorProfile
     * const fasilitatorProfile = await prisma.fasilitatorProfile.upsert({
     *   create: {
     *     // ... data to create a FasilitatorProfile
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the FasilitatorProfile we want to update
     *   }
     * })
     */
    upsert<T extends FasilitatorProfileUpsertArgs>(args: SelectSubset<T, FasilitatorProfileUpsertArgs<ExtArgs>>): Prisma__FasilitatorProfileClient<$Result.GetResult<Prisma.$FasilitatorProfilePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of FasilitatorProfiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileCountArgs} args - Arguments to filter FasilitatorProfiles to count.
     * @example
     * // Count the number of FasilitatorProfiles
     * const count = await prisma.fasilitatorProfile.count({
     *   where: {
     *     // ... the filter for the FasilitatorProfiles we want to count
     *   }
     * })
    **/
    count<T extends FasilitatorProfileCountArgs>(
      args?: Subset<T, FasilitatorProfileCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], FasilitatorProfileCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a FasilitatorProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileAggregateArgs} 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 FasilitatorProfileAggregateArgs>(args: Subset<T, FasilitatorProfileAggregateArgs>): Prisma.PrismaPromise<GetFasilitatorProfileAggregateType<T>>

    /**
     * Group by FasilitatorProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FasilitatorProfileGroupByArgs} 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 FasilitatorProfileGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: FasilitatorProfileGroupByArgs['orderBy'] }
        : { orderBy?: FasilitatorProfileGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, FasilitatorProfileGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFasilitatorProfileGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the FasilitatorProfile model
   */
  readonly fields: FasilitatorProfileFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for FasilitatorProfile.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__FasilitatorProfileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the FasilitatorProfile model
   */
  interface FasilitatorProfileFieldRefs {
    readonly id: FieldRef<"FasilitatorProfile", 'String'>
    readonly userId: FieldRef<"FasilitatorProfile", 'String'>
    readonly university: FieldRef<"FasilitatorProfile", 'String'>
  }
    

  // Custom InputTypes
  /**
   * FasilitatorProfile findUnique
   */
  export type FasilitatorProfileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * Filter, which FasilitatorProfile to fetch.
     */
    where: FasilitatorProfileWhereUniqueInput
  }

  /**
   * FasilitatorProfile findUniqueOrThrow
   */
  export type FasilitatorProfileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * Filter, which FasilitatorProfile to fetch.
     */
    where: FasilitatorProfileWhereUniqueInput
  }

  /**
   * FasilitatorProfile findFirst
   */
  export type FasilitatorProfileFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * Filter, which FasilitatorProfile to fetch.
     */
    where?: FasilitatorProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FasilitatorProfiles to fetch.
     */
    orderBy?: FasilitatorProfileOrderByWithRelationInput | FasilitatorProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FasilitatorProfiles.
     */
    cursor?: FasilitatorProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FasilitatorProfiles 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` FasilitatorProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FasilitatorProfiles.
     */
    distinct?: FasilitatorProfileScalarFieldEnum | FasilitatorProfileScalarFieldEnum[]
  }

  /**
   * FasilitatorProfile findFirstOrThrow
   */
  export type FasilitatorProfileFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * Filter, which FasilitatorProfile to fetch.
     */
    where?: FasilitatorProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FasilitatorProfiles to fetch.
     */
    orderBy?: FasilitatorProfileOrderByWithRelationInput | FasilitatorProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FasilitatorProfiles.
     */
    cursor?: FasilitatorProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FasilitatorProfiles 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` FasilitatorProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FasilitatorProfiles.
     */
    distinct?: FasilitatorProfileScalarFieldEnum | FasilitatorProfileScalarFieldEnum[]
  }

  /**
   * FasilitatorProfile findMany
   */
  export type FasilitatorProfileFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * Filter, which FasilitatorProfiles to fetch.
     */
    where?: FasilitatorProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FasilitatorProfiles to fetch.
     */
    orderBy?: FasilitatorProfileOrderByWithRelationInput | FasilitatorProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing FasilitatorProfiles.
     */
    cursor?: FasilitatorProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FasilitatorProfiles 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` FasilitatorProfiles.
     */
    skip?: number
    distinct?: FasilitatorProfileScalarFieldEnum | FasilitatorProfileScalarFieldEnum[]
  }

  /**
   * FasilitatorProfile create
   */
  export type FasilitatorProfileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * The data needed to create a FasilitatorProfile.
     */
    data: XOR<FasilitatorProfileCreateInput, FasilitatorProfileUncheckedCreateInput>
  }

  /**
   * FasilitatorProfile createMany
   */
  export type FasilitatorProfileCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many FasilitatorProfiles.
     */
    data: FasilitatorProfileCreateManyInput | FasilitatorProfileCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * FasilitatorProfile update
   */
  export type FasilitatorProfileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * The data needed to update a FasilitatorProfile.
     */
    data: XOR<FasilitatorProfileUpdateInput, FasilitatorProfileUncheckedUpdateInput>
    /**
     * Choose, which FasilitatorProfile to update.
     */
    where: FasilitatorProfileWhereUniqueInput
  }

  /**
   * FasilitatorProfile updateMany
   */
  export type FasilitatorProfileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update FasilitatorProfiles.
     */
    data: XOR<FasilitatorProfileUpdateManyMutationInput, FasilitatorProfileUncheckedUpdateManyInput>
    /**
     * Filter which FasilitatorProfiles to update
     */
    where?: FasilitatorProfileWhereInput
    /**
     * Limit how many FasilitatorProfiles to update.
     */
    limit?: number
  }

  /**
   * FasilitatorProfile upsert
   */
  export type FasilitatorProfileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * The filter to search for the FasilitatorProfile to update in case it exists.
     */
    where: FasilitatorProfileWhereUniqueInput
    /**
     * In case the FasilitatorProfile found by the `where` argument doesn't exist, create a new FasilitatorProfile with this data.
     */
    create: XOR<FasilitatorProfileCreateInput, FasilitatorProfileUncheckedCreateInput>
    /**
     * In case the FasilitatorProfile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FasilitatorProfileUpdateInput, FasilitatorProfileUncheckedUpdateInput>
  }

  /**
   * FasilitatorProfile delete
   */
  export type FasilitatorProfileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
    /**
     * Filter which FasilitatorProfile to delete.
     */
    where: FasilitatorProfileWhereUniqueInput
  }

  /**
   * FasilitatorProfile deleteMany
   */
  export type FasilitatorProfileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FasilitatorProfiles to delete
     */
    where?: FasilitatorProfileWhereInput
    /**
     * Limit how many FasilitatorProfiles to delete.
     */
    limit?: number
  }

  /**
   * FasilitatorProfile without action
   */
  export type FasilitatorProfileDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FasilitatorProfile
     */
    select?: FasilitatorProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the FasilitatorProfile
     */
    omit?: FasilitatorProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FasilitatorProfileInclude<ExtArgs> | null
  }


  /**
   * Model University
   */

  export type AggregateUniversity = {
    _count: UniversityCountAggregateOutputType | null
    _avg: UniversityAvgAggregateOutputType | null
    _sum: UniversitySumAggregateOutputType | null
    _min: UniversityMinAggregateOutputType | null
    _max: UniversityMaxAggregateOutputType | null
  }

  export type UniversityAvgAggregateOutputType = {
    latitude: number | null
    longitude: number | null
  }

  export type UniversitySumAggregateOutputType = {
    latitude: number | null
    longitude: number | null
  }

  export type UniversityMinAggregateOutputType = {
    id: string | null
    name: string | null
    alias: string | null
    location: string | null
    latitude: number | null
    longitude: number | null
    image: string | null
    createdAt: Date | null
    updateAt: Date | null
  }

  export type UniversityMaxAggregateOutputType = {
    id: string | null
    name: string | null
    alias: string | null
    location: string | null
    latitude: number | null
    longitude: number | null
    image: string | null
    createdAt: Date | null
    updateAt: Date | null
  }

  export type UniversityCountAggregateOutputType = {
    id: number
    name: number
    alias: number
    location: number
    latitude: number
    longitude: number
    image: number
    createdAt: number
    updateAt: number
    _all: number
  }


  export type UniversityAvgAggregateInputType = {
    latitude?: true
    longitude?: true
  }

  export type UniversitySumAggregateInputType = {
    latitude?: true
    longitude?: true
  }

  export type UniversityMinAggregateInputType = {
    id?: true
    name?: true
    alias?: true
    location?: true
    latitude?: true
    longitude?: true
    image?: true
    createdAt?: true
    updateAt?: true
  }

  export type UniversityMaxAggregateInputType = {
    id?: true
    name?: true
    alias?: true
    location?: true
    latitude?: true
    longitude?: true
    image?: true
    createdAt?: true
    updateAt?: true
  }

  export type UniversityCountAggregateInputType = {
    id?: true
    name?: true
    alias?: true
    location?: true
    latitude?: true
    longitude?: true
    image?: true
    createdAt?: true
    updateAt?: true
    _all?: true
  }

  export type UniversityAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which University to aggregate.
     */
    where?: UniversityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Universities to fetch.
     */
    orderBy?: UniversityOrderByWithRelationInput | UniversityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UniversityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Universities 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` Universities.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Universities
    **/
    _count?: true | UniversityCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UniversityAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UniversitySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UniversityMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UniversityMaxAggregateInputType
  }

  export type GetUniversityAggregateType<T extends UniversityAggregateArgs> = {
        [P in keyof T & keyof AggregateUniversity]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateUniversity[P]>
      : GetScalarType<T[P], AggregateUniversity[P]>
  }




  export type UniversityGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UniversityWhereInput
    orderBy?: UniversityOrderByWithAggregationInput | UniversityOrderByWithAggregationInput[]
    by: UniversityScalarFieldEnum[] | UniversityScalarFieldEnum
    having?: UniversityScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UniversityCountAggregateInputType | true
    _avg?: UniversityAvgAggregateInputType
    _sum?: UniversitySumAggregateInputType
    _min?: UniversityMinAggregateInputType
    _max?: UniversityMaxAggregateInputType
  }

  export type UniversityGroupByOutputType = {
    id: string
    name: string
    alias: string
    location: string
    latitude: number | null
    longitude: number | null
    image: string | null
    createdAt: Date
    updateAt: Date
    _count: UniversityCountAggregateOutputType | null
    _avg: UniversityAvgAggregateOutputType | null
    _sum: UniversitySumAggregateOutputType | null
    _min: UniversityMinAggregateOutputType | null
    _max: UniversityMaxAggregateOutputType | null
  }

  type GetUniversityGroupByPayload<T extends UniversityGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<UniversityGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof UniversityGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], UniversityGroupByOutputType[P]>
            : GetScalarType<T[P], UniversityGroupByOutputType[P]>
        }
      >
    >


  export type UniversitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    alias?: boolean
    location?: boolean
    latitude?: boolean
    longitude?: boolean
    image?: boolean
    createdAt?: boolean
    updateAt?: boolean
    koasProfile?: boolean | University$koasProfileArgs<ExtArgs>
    _count?: boolean | UniversityCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["university"]>



  export type UniversitySelectScalar = {
    id?: boolean
    name?: boolean
    alias?: boolean
    location?: boolean
    latitude?: boolean
    longitude?: boolean
    image?: boolean
    createdAt?: boolean
    updateAt?: boolean
  }

  export type UniversityOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "alias" | "location" | "latitude" | "longitude" | "image" | "createdAt" | "updateAt", ExtArgs["result"]["university"]>
  export type UniversityInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    koasProfile?: boolean | University$koasProfileArgs<ExtArgs>
    _count?: boolean | UniversityCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $UniversityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "University"
    objects: {
      koasProfile: Prisma.$KoasProfilePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      alias: string
      location: string
      latitude: number | null
      longitude: number | null
      image: string | null
      createdAt: Date
      updateAt: Date
    }, ExtArgs["result"]["university"]>
    composites: {}
  }

  type UniversityGetPayload<S extends boolean | null | undefined | UniversityDefaultArgs> = $Result.GetResult<Prisma.$UniversityPayload, S>

  type UniversityCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<UniversityFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: UniversityCountAggregateInputType | true
    }

  export interface UniversityDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['University'], meta: { name: 'University' } }
    /**
     * Find zero or one University that matches the filter.
     * @param {UniversityFindUniqueArgs} args - Arguments to find a University
     * @example
     * // Get one University
     * const university = await prisma.university.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends UniversityFindUniqueArgs>(args: SelectSubset<T, UniversityFindUniqueArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one University that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {UniversityFindUniqueOrThrowArgs} args - Arguments to find a University
     * @example
     * // Get one University
     * const university = await prisma.university.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends UniversityFindUniqueOrThrowArgs>(args: SelectSubset<T, UniversityFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first University that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityFindFirstArgs} args - Arguments to find a University
     * @example
     * // Get one University
     * const university = await prisma.university.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends UniversityFindFirstArgs>(args?: SelectSubset<T, UniversityFindFirstArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first University that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityFindFirstOrThrowArgs} args - Arguments to find a University
     * @example
     * // Get one University
     * const university = await prisma.university.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends UniversityFindFirstOrThrowArgs>(args?: SelectSubset<T, UniversityFindFirstOrThrowArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Universities that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Universities
     * const universities = await prisma.university.findMany()
     * 
     * // Get first 10 Universities
     * const universities = await prisma.university.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const universityWithIdOnly = await prisma.university.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends UniversityFindManyArgs>(args?: SelectSubset<T, UniversityFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a University.
     * @param {UniversityCreateArgs} args - Arguments to create a University.
     * @example
     * // Create one University
     * const University = await prisma.university.create({
     *   data: {
     *     // ... data to create a University
     *   }
     * })
     * 
     */
    create<T extends UniversityCreateArgs>(args: SelectSubset<T, UniversityCreateArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Universities.
     * @param {UniversityCreateManyArgs} args - Arguments to create many Universities.
     * @example
     * // Create many Universities
     * const university = await prisma.university.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends UniversityCreateManyArgs>(args?: SelectSubset<T, UniversityCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a University.
     * @param {UniversityDeleteArgs} args - Arguments to delete one University.
     * @example
     * // Delete one University
     * const University = await prisma.university.delete({
     *   where: {
     *     // ... filter to delete one University
     *   }
     * })
     * 
     */
    delete<T extends UniversityDeleteArgs>(args: SelectSubset<T, UniversityDeleteArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one University.
     * @param {UniversityUpdateArgs} args - Arguments to update one University.
     * @example
     * // Update one University
     * const university = await prisma.university.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends UniversityUpdateArgs>(args: SelectSubset<T, UniversityUpdateArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Universities.
     * @param {UniversityDeleteManyArgs} args - Arguments to filter Universities to delete.
     * @example
     * // Delete a few Universities
     * const { count } = await prisma.university.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends UniversityDeleteManyArgs>(args?: SelectSubset<T, UniversityDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Universities.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Universities
     * const university = await prisma.university.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends UniversityUpdateManyArgs>(args: SelectSubset<T, UniversityUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one University.
     * @param {UniversityUpsertArgs} args - Arguments to update or create a University.
     * @example
     * // Update or create a University
     * const university = await prisma.university.upsert({
     *   create: {
     *     // ... data to create a University
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the University we want to update
     *   }
     * })
     */
    upsert<T extends UniversityUpsertArgs>(args: SelectSubset<T, UniversityUpsertArgs<ExtArgs>>): Prisma__UniversityClient<$Result.GetResult<Prisma.$UniversityPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Universities.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityCountArgs} args - Arguments to filter Universities to count.
     * @example
     * // Count the number of Universities
     * const count = await prisma.university.count({
     *   where: {
     *     // ... the filter for the Universities we want to count
     *   }
     * })
    **/
    count<T extends UniversityCountArgs>(
      args?: Subset<T, UniversityCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], UniversityCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a University.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityAggregateArgs} 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 UniversityAggregateArgs>(args: Subset<T, UniversityAggregateArgs>): Prisma.PrismaPromise<GetUniversityAggregateType<T>>

    /**
     * Group by University.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UniversityGroupByArgs} 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 UniversityGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: UniversityGroupByArgs['orderBy'] }
        : { orderBy?: UniversityGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, UniversityGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUniversityGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the University model
   */
  readonly fields: UniversityFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for University.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__UniversityClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    koasProfile<T extends University$koasProfileArgs<ExtArgs> = {}>(args?: Subset<T, University$koasProfileArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the University model
   */
  interface UniversityFieldRefs {
    readonly id: FieldRef<"University", 'String'>
    readonly name: FieldRef<"University", 'String'>
    readonly alias: FieldRef<"University", 'String'>
    readonly location: FieldRef<"University", 'String'>
    readonly latitude: FieldRef<"University", 'Float'>
    readonly longitude: FieldRef<"University", 'Float'>
    readonly image: FieldRef<"University", 'String'>
    readonly createdAt: FieldRef<"University", 'DateTime'>
    readonly updateAt: FieldRef<"University", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * University findUnique
   */
  export type UniversityFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * Filter, which University to fetch.
     */
    where: UniversityWhereUniqueInput
  }

  /**
   * University findUniqueOrThrow
   */
  export type UniversityFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * Filter, which University to fetch.
     */
    where: UniversityWhereUniqueInput
  }

  /**
   * University findFirst
   */
  export type UniversityFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * Filter, which University to fetch.
     */
    where?: UniversityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Universities to fetch.
     */
    orderBy?: UniversityOrderByWithRelationInput | UniversityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Universities.
     */
    cursor?: UniversityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Universities 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` Universities.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Universities.
     */
    distinct?: UniversityScalarFieldEnum | UniversityScalarFieldEnum[]
  }

  /**
   * University findFirstOrThrow
   */
  export type UniversityFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * Filter, which University to fetch.
     */
    where?: UniversityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Universities to fetch.
     */
    orderBy?: UniversityOrderByWithRelationInput | UniversityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Universities.
     */
    cursor?: UniversityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Universities 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` Universities.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Universities.
     */
    distinct?: UniversityScalarFieldEnum | UniversityScalarFieldEnum[]
  }

  /**
   * University findMany
   */
  export type UniversityFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * Filter, which Universities to fetch.
     */
    where?: UniversityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Universities to fetch.
     */
    orderBy?: UniversityOrderByWithRelationInput | UniversityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Universities.
     */
    cursor?: UniversityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Universities 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` Universities.
     */
    skip?: number
    distinct?: UniversityScalarFieldEnum | UniversityScalarFieldEnum[]
  }

  /**
   * University create
   */
  export type UniversityCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * The data needed to create a University.
     */
    data: XOR<UniversityCreateInput, UniversityUncheckedCreateInput>
  }

  /**
   * University createMany
   */
  export type UniversityCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Universities.
     */
    data: UniversityCreateManyInput | UniversityCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * University update
   */
  export type UniversityUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * The data needed to update a University.
     */
    data: XOR<UniversityUpdateInput, UniversityUncheckedUpdateInput>
    /**
     * Choose, which University to update.
     */
    where: UniversityWhereUniqueInput
  }

  /**
   * University updateMany
   */
  export type UniversityUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Universities.
     */
    data: XOR<UniversityUpdateManyMutationInput, UniversityUncheckedUpdateManyInput>
    /**
     * Filter which Universities to update
     */
    where?: UniversityWhereInput
    /**
     * Limit how many Universities to update.
     */
    limit?: number
  }

  /**
   * University upsert
   */
  export type UniversityUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * The filter to search for the University to update in case it exists.
     */
    where: UniversityWhereUniqueInput
    /**
     * In case the University found by the `where` argument doesn't exist, create a new University with this data.
     */
    create: XOR<UniversityCreateInput, UniversityUncheckedCreateInput>
    /**
     * In case the University was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UniversityUpdateInput, UniversityUncheckedUpdateInput>
  }

  /**
   * University delete
   */
  export type UniversityDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
    /**
     * Filter which University to delete.
     */
    where: UniversityWhereUniqueInput
  }

  /**
   * University deleteMany
   */
  export type UniversityDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Universities to delete
     */
    where?: UniversityWhereInput
    /**
     * Limit how many Universities to delete.
     */
    limit?: number
  }

  /**
   * University.koasProfile
   */
  export type University$koasProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    where?: KoasProfileWhereInput
    orderBy?: KoasProfileOrderByWithRelationInput | KoasProfileOrderByWithRelationInput[]
    cursor?: KoasProfileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: KoasProfileScalarFieldEnum | KoasProfileScalarFieldEnum[]
  }

  /**
   * University without action
   */
  export type UniversityDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the University
     */
    select?: UniversitySelect<ExtArgs> | null
    /**
     * Omit specific fields from the University
     */
    omit?: UniversityOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UniversityInclude<ExtArgs> | null
  }


  /**
   * Model Post
   */

  export type AggregatePost = {
    _count: PostCountAggregateOutputType | null
    _avg: PostAvgAggregateOutputType | null
    _sum: PostSumAggregateOutputType | null
    _min: PostMinAggregateOutputType | null
    _max: PostMaxAggregateOutputType | null
  }

  export type PostAvgAggregateOutputType = {
    requiredParticipant: number | null
  }

  export type PostSumAggregateOutputType = {
    requiredParticipant: number | null
  }

  export type PostMinAggregateOutputType = {
    id: string | null
    userId: string | null
    koasId: string | null
    treatmentId: string | null
    title: string | null
    desc: string | null
    status: $Enums.StatusPost | null
    published: boolean | null
    createdAt: Date | null
    updateAt: Date | null
    requiredParticipant: number | null
  }

  export type PostMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    koasId: string | null
    treatmentId: string | null
    title: string | null
    desc: string | null
    status: $Enums.StatusPost | null
    published: boolean | null
    createdAt: Date | null
    updateAt: Date | null
    requiredParticipant: number | null
  }

  export type PostCountAggregateOutputType = {
    id: number
    userId: number
    koasId: number
    treatmentId: number
    title: number
    desc: number
    patientRequirement: number
    status: number
    published: number
    createdAt: number
    updateAt: number
    requiredParticipant: number
    images: number
    _all: number
  }


  export type PostAvgAggregateInputType = {
    requiredParticipant?: true
  }

  export type PostSumAggregateInputType = {
    requiredParticipant?: true
  }

  export type PostMinAggregateInputType = {
    id?: true
    userId?: true
    koasId?: true
    treatmentId?: true
    title?: true
    desc?: true
    status?: true
    published?: true
    createdAt?: true
    updateAt?: true
    requiredParticipant?: true
  }

  export type PostMaxAggregateInputType = {
    id?: true
    userId?: true
    koasId?: true
    treatmentId?: true
    title?: true
    desc?: true
    status?: true
    published?: true
    createdAt?: true
    updateAt?: true
    requiredParticipant?: true
  }

  export type PostCountAggregateInputType = {
    id?: true
    userId?: true
    koasId?: true
    treatmentId?: true
    title?: true
    desc?: true
    patientRequirement?: true
    status?: true
    published?: true
    createdAt?: true
    updateAt?: true
    requiredParticipant?: true
    images?: true
    _all?: true
  }

  export type PostAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * 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?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    /**
     * {@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 | PostCountAggregateInputType
    /**
     * {@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 PostAggregateArgs> = {
        [P in keyof T & keyof AggregatePost]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePost[P]>
      : GetScalarType<T[P], AggregatePost[P]>
  }




  export type PostGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PostWhereInput
    orderBy?: PostOrderByWithAggregationInput | PostOrderByWithAggregationInput[]
    by: PostScalarFieldEnum[] | PostScalarFieldEnum
    having?: PostScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PostCountAggregateInputType | true
    _avg?: PostAvgAggregateInputType
    _sum?: PostSumAggregateInputType
    _min?: PostMinAggregateInputType
    _max?: PostMaxAggregateInputType
  }

  export type PostGroupByOutputType = {
    id: string
    userId: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement: JsonValue | null
    status: $Enums.StatusPost
    published: boolean
    createdAt: Date
    updateAt: Date
    requiredParticipant: number
    images: JsonValue | null
    _count: PostCountAggregateOutputType | null
    _avg: PostAvgAggregateOutputType | null
    _sum: PostSumAggregateOutputType | null
    _min: PostMinAggregateOutputType | null
    _max: PostMaxAggregateOutputType | null
  }

  type GetPostGroupByPayload<T extends PostGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PostGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PostGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PostGroupByOutputType[P]>
            : GetScalarType<T[P], PostGroupByOutputType[P]>
        }
      >
    >


  export type PostSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    koasId?: boolean
    treatmentId?: boolean
    title?: boolean
    desc?: boolean
    patientRequirement?: boolean
    status?: boolean
    published?: boolean
    createdAt?: boolean
    updateAt?: boolean
    requiredParticipant?: boolean
    images?: boolean
    likes?: boolean | Post$likesArgs<ExtArgs>
    koas?: boolean | KoasProfileDefaultArgs<ExtArgs>
    treatment?: boolean | TreatmentTypeDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    Review?: boolean | Post$ReviewArgs<ExtArgs>
    Schedule?: boolean | Post$ScheduleArgs<ExtArgs>
    _count?: boolean | PostCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["post"]>



  export type PostSelectScalar = {
    id?: boolean
    userId?: boolean
    koasId?: boolean
    treatmentId?: boolean
    title?: boolean
    desc?: boolean
    patientRequirement?: boolean
    status?: boolean
    published?: boolean
    createdAt?: boolean
    updateAt?: boolean
    requiredParticipant?: boolean
    images?: boolean
  }

  export type PostOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "userId" | "koasId" | "treatmentId" | "title" | "desc" | "patientRequirement" | "status" | "published" | "createdAt" | "updateAt" | "requiredParticipant" | "images", ExtArgs["result"]["post"]>
  export type PostInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    likes?: boolean | Post$likesArgs<ExtArgs>
    koas?: boolean | KoasProfileDefaultArgs<ExtArgs>
    treatment?: boolean | TreatmentTypeDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    Review?: boolean | Post$ReviewArgs<ExtArgs>
    Schedule?: boolean | Post$ScheduleArgs<ExtArgs>
    _count?: boolean | PostCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $PostPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Post"
    objects: {
      likes: Prisma.$LikePayload<ExtArgs>[]
      koas: Prisma.$KoasProfilePayload<ExtArgs>
      treatment: Prisma.$TreatmentTypePayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
      Review: Prisma.$ReviewPayload<ExtArgs>[]
      Schedule: Prisma.$SchedulePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string
      koasId: string
      treatmentId: string
      title: string
      desc: string
      patientRequirement: Prisma.JsonValue | null
      status: $Enums.StatusPost
      published: boolean
      createdAt: Date
      updateAt: Date
      requiredParticipant: number
      images: Prisma.JsonValue | null
    }, ExtArgs["result"]["post"]>
    composites: {}
  }

  type PostGetPayload<S extends boolean | null | undefined | PostDefaultArgs> = $Result.GetResult<Prisma.$PostPayload, S>

  type PostCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PostFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PostCountAggregateInputType | true
    }

  export interface PostDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Post'], meta: { name: 'Post' } }
    /**
     * Find zero or one Post that matches the filter.
     * @param {PostFindUniqueArgs} args - Arguments to find a Post
     * @example
     * // Get one Post
     * const post = await prisma.post.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends PostFindUniqueArgs>(args: SelectSubset<T, PostFindUniqueArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Post that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {PostFindUniqueOrThrowArgs} args - Arguments to find a Post
     * @example
     * // Get one Post
     * const post = await prisma.post.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends PostFindUniqueOrThrowArgs>(args: SelectSubset<T, PostFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Post that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PostFindFirstArgs} args - Arguments to find a Post
     * @example
     * // Get one Post
     * const post = await prisma.post.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PostFindFirstArgs>(args?: SelectSubset<T, PostFindFirstArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Post that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PostFindFirstOrThrowArgs} args - Arguments to find a Post
     * @example
     * // Get one Post
     * const post = await prisma.post.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PostFindFirstOrThrowArgs>(args?: SelectSubset<T, PostFindFirstOrThrowArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Posts that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PostFindManyArgs} 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 PostFindManyArgs>(args?: SelectSubset<T, PostFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * 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: SelectSubset<T, PostCreateArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Posts.
     * @param {PostCreateManyArgs} args - Arguments to create many Posts.
     * @example
     * // Create many Posts
     * const post = await prisma.post.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends PostCreateManyArgs>(args?: SelectSubset<T, PostCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * 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: SelectSubset<T, PostDeleteArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * 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: SelectSubset<T, PostUpdateArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * 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?: SelectSubset<T, PostDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Posts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @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: SelectSubset<T, PostUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<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: SelectSubset<T, PostUpsertArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Posts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PostCountArgs} 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<T extends PostCountArgs>(
      args?: Subset<T, PostCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PostCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Post.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PostAggregateArgs} 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 PostAggregateArgs>(args: Subset<T, PostAggregateArgs>): Prisma.PrismaPromise<GetPostAggregateType<T>>

    /**
     * Group by Post.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PostGroupByArgs} 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 PostGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PostGroupByArgs['orderBy'] }
        : { orderBy?: PostGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, PostGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPostGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Post model
   */
  readonly fields: PostFieldRefs;
  }

  /**
   * 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
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__PostClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    likes<T extends Post$likesArgs<ExtArgs> = {}>(args?: Subset<T, Post$likesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    koas<T extends KoasProfileDefaultArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfileDefaultArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    treatment<T extends TreatmentTypeDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TreatmentTypeDefaultArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    Review<T extends Post$ReviewArgs<ExtArgs> = {}>(args?: Subset<T, Post$ReviewArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    Schedule<T extends Post$ScheduleArgs<ExtArgs> = {}>(args?: Subset<T, Post$ScheduleArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Post model
   */
  interface PostFieldRefs {
    readonly id: FieldRef<"Post", 'String'>
    readonly userId: FieldRef<"Post", 'String'>
    readonly koasId: FieldRef<"Post", 'String'>
    readonly treatmentId: FieldRef<"Post", 'String'>
    readonly title: FieldRef<"Post", 'String'>
    readonly desc: FieldRef<"Post", 'String'>
    readonly patientRequirement: FieldRef<"Post", 'Json'>
    readonly status: FieldRef<"Post", 'StatusPost'>
    readonly published: FieldRef<"Post", 'Boolean'>
    readonly createdAt: FieldRef<"Post", 'DateTime'>
    readonly updateAt: FieldRef<"Post", 'DateTime'>
    readonly requiredParticipant: FieldRef<"Post", 'Int'>
    readonly images: FieldRef<"Post", 'Json'>
  }
    

  // Custom InputTypes
  /**
   * Post findUnique
   */
  export type PostFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
    /**
     * Filter, which Post to fetch.
     */
    where: PostWhereUniqueInput
  }

  /**
   * Post findUniqueOrThrow
   */
  export type PostFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
    /**
     * Filter, which Post to fetch.
     */
    where: PostWhereUniqueInput
  }

  /**
   * Post findFirst
   */
  export type PostFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | 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?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    /**
     * {@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?: PostScalarFieldEnum | PostScalarFieldEnum[]
  }

  /**
   * Post findFirstOrThrow
   */
  export type PostFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | 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?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    /**
     * {@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?: PostScalarFieldEnum | PostScalarFieldEnum[]
  }

  /**
   * Post findMany
   */
  export type PostFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | 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?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    /**
     * {@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?: PostScalarFieldEnum | PostScalarFieldEnum[]
  }

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

  /**
   * Post createMany
   */
  export type PostCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Posts.
     */
    data: PostCreateManyInput | PostCreateManyInput[]
    skipDuplicates?: boolean
  }

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

  /**
   * Post updateMany
   */
  export type PostUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Posts.
     */
    data: XOR<PostUpdateManyMutationInput, PostUncheckedUpdateManyInput>
    /**
     * Filter which Posts to update
     */
    where?: PostWhereInput
    /**
     * Limit how many Posts to update.
     */
    limit?: number
  }

  /**
   * Post upsert
   */
  export type PostUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | 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<PostCreateInput, PostUncheckedCreateInput>
    /**
     * In case the Post was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PostUpdateInput, PostUncheckedUpdateInput>
  }

  /**
   * Post delete
   */
  export type PostDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
    /**
     * Filter which Post to delete.
     */
    where: PostWhereUniqueInput
  }

  /**
   * Post deleteMany
   */
  export type PostDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Posts to delete
     */
    where?: PostWhereInput
    /**
     * Limit how many Posts to delete.
     */
    limit?: number
  }

  /**
   * Post.likes
   */
  export type Post$likesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    where?: LikeWhereInput
    orderBy?: LikeOrderByWithRelationInput | LikeOrderByWithRelationInput[]
    cursor?: LikeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LikeScalarFieldEnum | LikeScalarFieldEnum[]
  }

  /**
   * Post.Review
   */
  export type Post$ReviewArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    where?: ReviewWhereInput
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    cursor?: ReviewWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ReviewScalarFieldEnum | ReviewScalarFieldEnum[]
  }

  /**
   * Post.Schedule
   */
  export type Post$ScheduleArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    where?: ScheduleWhereInput
    orderBy?: ScheduleOrderByWithRelationInput | ScheduleOrderByWithRelationInput[]
    cursor?: ScheduleWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ScheduleScalarFieldEnum | ScheduleScalarFieldEnum[]
  }

  /**
   * Post without action
   */
  export type PostDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
  }


  /**
   * Model Like
   */

  export type AggregateLike = {
    _count: LikeCountAggregateOutputType | null
    _min: LikeMinAggregateOutputType | null
    _max: LikeMaxAggregateOutputType | null
  }

  export type LikeMinAggregateOutputType = {
    id: string | null
    postId: string | null
    userId: string | null
    createdAt: Date | null
  }

  export type LikeMaxAggregateOutputType = {
    id: string | null
    postId: string | null
    userId: string | null
    createdAt: Date | null
  }

  export type LikeCountAggregateOutputType = {
    id: number
    postId: number
    userId: number
    createdAt: number
    _all: number
  }


  export type LikeMinAggregateInputType = {
    id?: true
    postId?: true
    userId?: true
    createdAt?: true
  }

  export type LikeMaxAggregateInputType = {
    id?: true
    postId?: true
    userId?: true
    createdAt?: true
  }

  export type LikeCountAggregateInputType = {
    id?: true
    postId?: true
    userId?: true
    createdAt?: true
    _all?: true
  }

  export type LikeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Like to aggregate.
     */
    where?: LikeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Likes to fetch.
     */
    orderBy?: LikeOrderByWithRelationInput | LikeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: LikeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Likes 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` Likes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Likes
    **/
    _count?: true | LikeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: LikeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: LikeMaxAggregateInputType
  }

  export type GetLikeAggregateType<T extends LikeAggregateArgs> = {
        [P in keyof T & keyof AggregateLike]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateLike[P]>
      : GetScalarType<T[P], AggregateLike[P]>
  }




  export type LikeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LikeWhereInput
    orderBy?: LikeOrderByWithAggregationInput | LikeOrderByWithAggregationInput[]
    by: LikeScalarFieldEnum[] | LikeScalarFieldEnum
    having?: LikeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LikeCountAggregateInputType | true
    _min?: LikeMinAggregateInputType
    _max?: LikeMaxAggregateInputType
  }

  export type LikeGroupByOutputType = {
    id: string
    postId: string
    userId: string
    createdAt: Date
    _count: LikeCountAggregateOutputType | null
    _min: LikeMinAggregateOutputType | null
    _max: LikeMaxAggregateOutputType | null
  }

  type GetLikeGroupByPayload<T extends LikeGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<LikeGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof LikeGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], LikeGroupByOutputType[P]>
            : GetScalarType<T[P], LikeGroupByOutputType[P]>
        }
      >
    >


  export type LikeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    postId?: boolean
    userId?: boolean
    createdAt?: boolean
    Post?: boolean | PostDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["like"]>



  export type LikeSelectScalar = {
    id?: boolean
    postId?: boolean
    userId?: boolean
    createdAt?: boolean
  }

  export type LikeOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "postId" | "userId" | "createdAt", ExtArgs["result"]["like"]>
  export type LikeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Post?: boolean | PostDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $LikePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Like"
    objects: {
      Post: Prisma.$PostPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      postId: string
      userId: string
      createdAt: Date
    }, ExtArgs["result"]["like"]>
    composites: {}
  }

  type LikeGetPayload<S extends boolean | null | undefined | LikeDefaultArgs> = $Result.GetResult<Prisma.$LikePayload, S>

  type LikeCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<LikeFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: LikeCountAggregateInputType | true
    }

  export interface LikeDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Like'], meta: { name: 'Like' } }
    /**
     * Find zero or one Like that matches the filter.
     * @param {LikeFindUniqueArgs} args - Arguments to find a Like
     * @example
     * // Get one Like
     * const like = await prisma.like.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends LikeFindUniqueArgs>(args: SelectSubset<T, LikeFindUniqueArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Like that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {LikeFindUniqueOrThrowArgs} args - Arguments to find a Like
     * @example
     * // Get one Like
     * const like = await prisma.like.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends LikeFindUniqueOrThrowArgs>(args: SelectSubset<T, LikeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Like that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeFindFirstArgs} args - Arguments to find a Like
     * @example
     * // Get one Like
     * const like = await prisma.like.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends LikeFindFirstArgs>(args?: SelectSubset<T, LikeFindFirstArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Like that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeFindFirstOrThrowArgs} args - Arguments to find a Like
     * @example
     * // Get one Like
     * const like = await prisma.like.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends LikeFindFirstOrThrowArgs>(args?: SelectSubset<T, LikeFindFirstOrThrowArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Likes that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Likes
     * const likes = await prisma.like.findMany()
     * 
     * // Get first 10 Likes
     * const likes = await prisma.like.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const likeWithIdOnly = await prisma.like.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends LikeFindManyArgs>(args?: SelectSubset<T, LikeFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Like.
     * @param {LikeCreateArgs} args - Arguments to create a Like.
     * @example
     * // Create one Like
     * const Like = await prisma.like.create({
     *   data: {
     *     // ... data to create a Like
     *   }
     * })
     * 
     */
    create<T extends LikeCreateArgs>(args: SelectSubset<T, LikeCreateArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Likes.
     * @param {LikeCreateManyArgs} args - Arguments to create many Likes.
     * @example
     * // Create many Likes
     * const like = await prisma.like.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends LikeCreateManyArgs>(args?: SelectSubset<T, LikeCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Like.
     * @param {LikeDeleteArgs} args - Arguments to delete one Like.
     * @example
     * // Delete one Like
     * const Like = await prisma.like.delete({
     *   where: {
     *     // ... filter to delete one Like
     *   }
     * })
     * 
     */
    delete<T extends LikeDeleteArgs>(args: SelectSubset<T, LikeDeleteArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Like.
     * @param {LikeUpdateArgs} args - Arguments to update one Like.
     * @example
     * // Update one Like
     * const like = await prisma.like.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends LikeUpdateArgs>(args: SelectSubset<T, LikeUpdateArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Likes.
     * @param {LikeDeleteManyArgs} args - Arguments to filter Likes to delete.
     * @example
     * // Delete a few Likes
     * const { count } = await prisma.like.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends LikeDeleteManyArgs>(args?: SelectSubset<T, LikeDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Likes.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Likes
     * const like = await prisma.like.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends LikeUpdateManyArgs>(args: SelectSubset<T, LikeUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Like.
     * @param {LikeUpsertArgs} args - Arguments to update or create a Like.
     * @example
     * // Update or create a Like
     * const like = await prisma.like.upsert({
     *   create: {
     *     // ... data to create a Like
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Like we want to update
     *   }
     * })
     */
    upsert<T extends LikeUpsertArgs>(args: SelectSubset<T, LikeUpsertArgs<ExtArgs>>): Prisma__LikeClient<$Result.GetResult<Prisma.$LikePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Likes.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeCountArgs} args - Arguments to filter Likes to count.
     * @example
     * // Count the number of Likes
     * const count = await prisma.like.count({
     *   where: {
     *     // ... the filter for the Likes we want to count
     *   }
     * })
    **/
    count<T extends LikeCountArgs>(
      args?: Subset<T, LikeCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], LikeCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Like.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeAggregateArgs} 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 LikeAggregateArgs>(args: Subset<T, LikeAggregateArgs>): Prisma.PrismaPromise<GetLikeAggregateType<T>>

    /**
     * Group by Like.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {LikeGroupByArgs} 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 LikeGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: LikeGroupByArgs['orderBy'] }
        : { orderBy?: LikeGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, LikeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetLikeGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Like model
   */
  readonly fields: LikeFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Like.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__LikeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Post<T extends PostDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PostDefaultArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Like model
   */
  interface LikeFieldRefs {
    readonly id: FieldRef<"Like", 'String'>
    readonly postId: FieldRef<"Like", 'String'>
    readonly userId: FieldRef<"Like", 'String'>
    readonly createdAt: FieldRef<"Like", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Like findUnique
   */
  export type LikeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * Filter, which Like to fetch.
     */
    where: LikeWhereUniqueInput
  }

  /**
   * Like findUniqueOrThrow
   */
  export type LikeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * Filter, which Like to fetch.
     */
    where: LikeWhereUniqueInput
  }

  /**
   * Like findFirst
   */
  export type LikeFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * Filter, which Like to fetch.
     */
    where?: LikeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Likes to fetch.
     */
    orderBy?: LikeOrderByWithRelationInput | LikeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Likes.
     */
    cursor?: LikeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Likes 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` Likes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Likes.
     */
    distinct?: LikeScalarFieldEnum | LikeScalarFieldEnum[]
  }

  /**
   * Like findFirstOrThrow
   */
  export type LikeFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * Filter, which Like to fetch.
     */
    where?: LikeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Likes to fetch.
     */
    orderBy?: LikeOrderByWithRelationInput | LikeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Likes.
     */
    cursor?: LikeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Likes 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` Likes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Likes.
     */
    distinct?: LikeScalarFieldEnum | LikeScalarFieldEnum[]
  }

  /**
   * Like findMany
   */
  export type LikeFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * Filter, which Likes to fetch.
     */
    where?: LikeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Likes to fetch.
     */
    orderBy?: LikeOrderByWithRelationInput | LikeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Likes.
     */
    cursor?: LikeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Likes 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` Likes.
     */
    skip?: number
    distinct?: LikeScalarFieldEnum | LikeScalarFieldEnum[]
  }

  /**
   * Like create
   */
  export type LikeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * The data needed to create a Like.
     */
    data: XOR<LikeCreateInput, LikeUncheckedCreateInput>
  }

  /**
   * Like createMany
   */
  export type LikeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Likes.
     */
    data: LikeCreateManyInput | LikeCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Like update
   */
  export type LikeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * The data needed to update a Like.
     */
    data: XOR<LikeUpdateInput, LikeUncheckedUpdateInput>
    /**
     * Choose, which Like to update.
     */
    where: LikeWhereUniqueInput
  }

  /**
   * Like updateMany
   */
  export type LikeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Likes.
     */
    data: XOR<LikeUpdateManyMutationInput, LikeUncheckedUpdateManyInput>
    /**
     * Filter which Likes to update
     */
    where?: LikeWhereInput
    /**
     * Limit how many Likes to update.
     */
    limit?: number
  }

  /**
   * Like upsert
   */
  export type LikeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * The filter to search for the Like to update in case it exists.
     */
    where: LikeWhereUniqueInput
    /**
     * In case the Like found by the `where` argument doesn't exist, create a new Like with this data.
     */
    create: XOR<LikeCreateInput, LikeUncheckedCreateInput>
    /**
     * In case the Like was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LikeUpdateInput, LikeUncheckedUpdateInput>
  }

  /**
   * Like delete
   */
  export type LikeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
    /**
     * Filter which Like to delete.
     */
    where: LikeWhereUniqueInput
  }

  /**
   * Like deleteMany
   */
  export type LikeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Likes to delete
     */
    where?: LikeWhereInput
    /**
     * Limit how many Likes to delete.
     */
    limit?: number
  }

  /**
   * Like without action
   */
  export type LikeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Like
     */
    select?: LikeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Like
     */
    omit?: LikeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LikeInclude<ExtArgs> | null
  }


  /**
   * Model Notification
   */

  export type AggregateNotification = {
    _count: NotificationCountAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

  export type NotificationMinAggregateOutputType = {
    id: string | null
    message: string | null
    createdAt: Date | null
    koasId: string | null
    senderId: string | null
    status: $Enums.StatusNotification | null
    title: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type NotificationMaxAggregateOutputType = {
    id: string | null
    message: string | null
    createdAt: Date | null
    koasId: string | null
    senderId: string | null
    status: $Enums.StatusNotification | null
    title: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type NotificationCountAggregateOutputType = {
    id: number
    message: number
    createdAt: number
    koasId: number
    senderId: number
    status: number
    title: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type NotificationMinAggregateInputType = {
    id?: true
    message?: true
    createdAt?: true
    koasId?: true
    senderId?: true
    status?: true
    title?: true
    updatedAt?: true
    userId?: true
  }

  export type NotificationMaxAggregateInputType = {
    id?: true
    message?: true
    createdAt?: true
    koasId?: true
    senderId?: true
    status?: true
    title?: true
    updatedAt?: true
    userId?: true
  }

  export type NotificationCountAggregateInputType = {
    id?: true
    message?: true
    createdAt?: true
    koasId?: true
    senderId?: true
    status?: true
    title?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type NotificationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Notification to aggregate.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications 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` Notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Notifications
    **/
    _count?: true | NotificationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: NotificationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: NotificationMaxAggregateInputType
  }

  export type GetNotificationAggregateType<T extends NotificationAggregateArgs> = {
        [P in keyof T & keyof AggregateNotification]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateNotification[P]>
      : GetScalarType<T[P], AggregateNotification[P]>
  }




  export type NotificationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithAggregationInput | NotificationOrderByWithAggregationInput[]
    by: NotificationScalarFieldEnum[] | NotificationScalarFieldEnum
    having?: NotificationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NotificationCountAggregateInputType | true
    _min?: NotificationMinAggregateInputType
    _max?: NotificationMaxAggregateInputType
  }

  export type NotificationGroupByOutputType = {
    id: string
    message: string
    createdAt: Date
    koasId: string | null
    senderId: string | null
    status: $Enums.StatusNotification
    title: string
    updatedAt: Date
    userId: string | null
    _count: NotificationCountAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

  type GetNotificationGroupByPayload<T extends NotificationGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<NotificationGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof NotificationGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], NotificationGroupByOutputType[P]>
            : GetScalarType<T[P], NotificationGroupByOutputType[P]>
        }
      >
    >


  export type NotificationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    message?: boolean
    createdAt?: boolean
    koasId?: boolean
    senderId?: boolean
    status?: boolean
    title?: boolean
    updatedAt?: boolean
    userId?: boolean
    koasProfile?: boolean | Notification$koasProfileArgs<ExtArgs>
    sender?: boolean | Notification$senderArgs<ExtArgs>
    recipient?: boolean | Notification$recipientArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>



  export type NotificationSelectScalar = {
    id?: boolean
    message?: boolean
    createdAt?: boolean
    koasId?: boolean
    senderId?: boolean
    status?: boolean
    title?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type NotificationOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "message" | "createdAt" | "koasId" | "senderId" | "status" | "title" | "updatedAt" | "userId", ExtArgs["result"]["notification"]>
  export type NotificationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    koasProfile?: boolean | Notification$koasProfileArgs<ExtArgs>
    sender?: boolean | Notification$senderArgs<ExtArgs>
    recipient?: boolean | Notification$recipientArgs<ExtArgs>
  }

  export type $NotificationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Notification"
    objects: {
      koasProfile: Prisma.$KoasProfilePayload<ExtArgs> | null
      sender: Prisma.$UserPayload<ExtArgs> | null
      recipient: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      message: string
      createdAt: Date
      koasId: string | null
      senderId: string | null
      status: $Enums.StatusNotification
      title: string
      updatedAt: Date
      userId: string | null
    }, ExtArgs["result"]["notification"]>
    composites: {}
  }

  type NotificationGetPayload<S extends boolean | null | undefined | NotificationDefaultArgs> = $Result.GetResult<Prisma.$NotificationPayload, S>

  type NotificationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<NotificationFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: NotificationCountAggregateInputType | true
    }

  export interface NotificationDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Notification'], meta: { name: 'Notification' } }
    /**
     * Find zero or one Notification that matches the filter.
     * @param {NotificationFindUniqueArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends NotificationFindUniqueArgs>(args: SelectSubset<T, NotificationFindUniqueArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Notification that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {NotificationFindUniqueOrThrowArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends NotificationFindUniqueOrThrowArgs>(args: SelectSubset<T, NotificationFindUniqueOrThrowArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Notification that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationFindFirstArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends NotificationFindFirstArgs>(args?: SelectSubset<T, NotificationFindFirstArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Notification that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationFindFirstOrThrowArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends NotificationFindFirstOrThrowArgs>(args?: SelectSubset<T, NotificationFindFirstOrThrowArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Notifications that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Notifications
     * const notifications = await prisma.notification.findMany()
     * 
     * // Get first 10 Notifications
     * const notifications = await prisma.notification.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const notificationWithIdOnly = await prisma.notification.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends NotificationFindManyArgs>(args?: SelectSubset<T, NotificationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Notification.
     * @param {NotificationCreateArgs} args - Arguments to create a Notification.
     * @example
     * // Create one Notification
     * const Notification = await prisma.notification.create({
     *   data: {
     *     // ... data to create a Notification
     *   }
     * })
     * 
     */
    create<T extends NotificationCreateArgs>(args: SelectSubset<T, NotificationCreateArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Notifications.
     * @param {NotificationCreateManyArgs} args - Arguments to create many Notifications.
     * @example
     * // Create many Notifications
     * const notification = await prisma.notification.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends NotificationCreateManyArgs>(args?: SelectSubset<T, NotificationCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Notification.
     * @param {NotificationDeleteArgs} args - Arguments to delete one Notification.
     * @example
     * // Delete one Notification
     * const Notification = await prisma.notification.delete({
     *   where: {
     *     // ... filter to delete one Notification
     *   }
     * })
     * 
     */
    delete<T extends NotificationDeleteArgs>(args: SelectSubset<T, NotificationDeleteArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Notification.
     * @param {NotificationUpdateArgs} args - Arguments to update one Notification.
     * @example
     * // Update one Notification
     * const notification = await prisma.notification.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends NotificationUpdateArgs>(args: SelectSubset<T, NotificationUpdateArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Notifications.
     * @param {NotificationDeleteManyArgs} args - Arguments to filter Notifications to delete.
     * @example
     * // Delete a few Notifications
     * const { count } = await prisma.notification.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends NotificationDeleteManyArgs>(args?: SelectSubset<T, NotificationDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Notifications.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Notifications
     * const notification = await prisma.notification.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends NotificationUpdateManyArgs>(args: SelectSubset<T, NotificationUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Notification.
     * @param {NotificationUpsertArgs} args - Arguments to update or create a Notification.
     * @example
     * // Update or create a Notification
     * const notification = await prisma.notification.upsert({
     *   create: {
     *     // ... data to create a Notification
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Notification we want to update
     *   }
     * })
     */
    upsert<T extends NotificationUpsertArgs>(args: SelectSubset<T, NotificationUpsertArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Notifications.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationCountArgs} args - Arguments to filter Notifications to count.
     * @example
     * // Count the number of Notifications
     * const count = await prisma.notification.count({
     *   where: {
     *     // ... the filter for the Notifications we want to count
     *   }
     * })
    **/
    count<T extends NotificationCountArgs>(
      args?: Subset<T, NotificationCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], NotificationCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Notification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationAggregateArgs} 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 NotificationAggregateArgs>(args: Subset<T, NotificationAggregateArgs>): Prisma.PrismaPromise<GetNotificationAggregateType<T>>

    /**
     * Group by Notification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationGroupByArgs} 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 NotificationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: NotificationGroupByArgs['orderBy'] }
        : { orderBy?: NotificationGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, NotificationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetNotificationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Notification model
   */
  readonly fields: NotificationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Notification.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__NotificationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    koasProfile<T extends Notification$koasProfileArgs<ExtArgs> = {}>(args?: Subset<T, Notification$koasProfileArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    sender<T extends Notification$senderArgs<ExtArgs> = {}>(args?: Subset<T, Notification$senderArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    recipient<T extends Notification$recipientArgs<ExtArgs> = {}>(args?: Subset<T, Notification$recipientArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Notification model
   */
  interface NotificationFieldRefs {
    readonly id: FieldRef<"Notification", 'String'>
    readonly message: FieldRef<"Notification", 'String'>
    readonly createdAt: FieldRef<"Notification", 'DateTime'>
    readonly koasId: FieldRef<"Notification", 'String'>
    readonly senderId: FieldRef<"Notification", 'String'>
    readonly status: FieldRef<"Notification", 'StatusNotification'>
    readonly title: FieldRef<"Notification", 'String'>
    readonly updatedAt: FieldRef<"Notification", 'DateTime'>
    readonly userId: FieldRef<"Notification", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Notification findUnique
   */
  export type NotificationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification findUniqueOrThrow
   */
  export type NotificationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification findFirst
   */
  export type NotificationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Notifications.
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications 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` Notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Notifications.
     */
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * Notification findFirstOrThrow
   */
  export type NotificationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Notifications.
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications 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` Notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Notifications.
     */
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * Notification findMany
   */
  export type NotificationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notifications to fetch.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Notifications.
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications 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` Notifications.
     */
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * Notification create
   */
  export type NotificationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The data needed to create a Notification.
     */
    data: XOR<NotificationCreateInput, NotificationUncheckedCreateInput>
  }

  /**
   * Notification createMany
   */
  export type NotificationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Notifications.
     */
    data: NotificationCreateManyInput | NotificationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Notification update
   */
  export type NotificationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The data needed to update a Notification.
     */
    data: XOR<NotificationUpdateInput, NotificationUncheckedUpdateInput>
    /**
     * Choose, which Notification to update.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification updateMany
   */
  export type NotificationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Notifications.
     */
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyInput>
    /**
     * Filter which Notifications to update
     */
    where?: NotificationWhereInput
    /**
     * Limit how many Notifications to update.
     */
    limit?: number
  }

  /**
   * Notification upsert
   */
  export type NotificationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The filter to search for the Notification to update in case it exists.
     */
    where: NotificationWhereUniqueInput
    /**
     * In case the Notification found by the `where` argument doesn't exist, create a new Notification with this data.
     */
    create: XOR<NotificationCreateInput, NotificationUncheckedCreateInput>
    /**
     * In case the Notification was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NotificationUpdateInput, NotificationUncheckedUpdateInput>
  }

  /**
   * Notification delete
   */
  export type NotificationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter which Notification to delete.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification deleteMany
   */
  export type NotificationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Notifications to delete
     */
    where?: NotificationWhereInput
    /**
     * Limit how many Notifications to delete.
     */
    limit?: number
  }

  /**
   * Notification.koasProfile
   */
  export type Notification$koasProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    where?: KoasProfileWhereInput
  }

  /**
   * Notification.sender
   */
  export type Notification$senderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
  }

  /**
   * Notification.recipient
   */
  export type Notification$recipientArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
  }

  /**
   * Notification without action
   */
  export type NotificationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Notification
     */
    omit?: NotificationOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
  }


  /**
   * Model TreatmentType
   */

  export type AggregateTreatmentType = {
    _count: TreatmentTypeCountAggregateOutputType | null
    _min: TreatmentTypeMinAggregateOutputType | null
    _max: TreatmentTypeMaxAggregateOutputType | null
  }

  export type TreatmentTypeMinAggregateOutputType = {
    id: string | null
    name: string | null
    createdAt: Date | null
    updateAt: Date | null
    alias: string | null
    image: string | null
  }

  export type TreatmentTypeMaxAggregateOutputType = {
    id: string | null
    name: string | null
    createdAt: Date | null
    updateAt: Date | null
    alias: string | null
    image: string | null
  }

  export type TreatmentTypeCountAggregateOutputType = {
    id: number
    name: number
    createdAt: number
    updateAt: number
    alias: number
    image: number
    _all: number
  }


  export type TreatmentTypeMinAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    updateAt?: true
    alias?: true
    image?: true
  }

  export type TreatmentTypeMaxAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    updateAt?: true
    alias?: true
    image?: true
  }

  export type TreatmentTypeCountAggregateInputType = {
    id?: true
    name?: true
    createdAt?: true
    updateAt?: true
    alias?: true
    image?: true
    _all?: true
  }

  export type TreatmentTypeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TreatmentType to aggregate.
     */
    where?: TreatmentTypeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TreatmentTypes to fetch.
     */
    orderBy?: TreatmentTypeOrderByWithRelationInput | TreatmentTypeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TreatmentTypeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TreatmentTypes 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` TreatmentTypes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TreatmentTypes
    **/
    _count?: true | TreatmentTypeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TreatmentTypeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TreatmentTypeMaxAggregateInputType
  }

  export type GetTreatmentTypeAggregateType<T extends TreatmentTypeAggregateArgs> = {
        [P in keyof T & keyof AggregateTreatmentType]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateTreatmentType[P]>
      : GetScalarType<T[P], AggregateTreatmentType[P]>
  }




  export type TreatmentTypeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TreatmentTypeWhereInput
    orderBy?: TreatmentTypeOrderByWithAggregationInput | TreatmentTypeOrderByWithAggregationInput[]
    by: TreatmentTypeScalarFieldEnum[] | TreatmentTypeScalarFieldEnum
    having?: TreatmentTypeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TreatmentTypeCountAggregateInputType | true
    _min?: TreatmentTypeMinAggregateInputType
    _max?: TreatmentTypeMaxAggregateInputType
  }

  export type TreatmentTypeGroupByOutputType = {
    id: string
    name: string
    createdAt: Date
    updateAt: Date
    alias: string
    image: string | null
    _count: TreatmentTypeCountAggregateOutputType | null
    _min: TreatmentTypeMinAggregateOutputType | null
    _max: TreatmentTypeMaxAggregateOutputType | null
  }

  type GetTreatmentTypeGroupByPayload<T extends TreatmentTypeGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<TreatmentTypeGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof TreatmentTypeGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], TreatmentTypeGroupByOutputType[P]>
            : GetScalarType<T[P], TreatmentTypeGroupByOutputType[P]>
        }
      >
    >


  export type TreatmentTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    createdAt?: boolean
    updateAt?: boolean
    alias?: boolean
    image?: boolean
    Post?: boolean | TreatmentType$PostArgs<ExtArgs>
    _count?: boolean | TreatmentTypeCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["treatmentType"]>



  export type TreatmentTypeSelectScalar = {
    id?: boolean
    name?: boolean
    createdAt?: boolean
    updateAt?: boolean
    alias?: boolean
    image?: boolean
  }

  export type TreatmentTypeOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "createdAt" | "updateAt" | "alias" | "image", ExtArgs["result"]["treatmentType"]>
  export type TreatmentTypeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Post?: boolean | TreatmentType$PostArgs<ExtArgs>
    _count?: boolean | TreatmentTypeCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $TreatmentTypePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TreatmentType"
    objects: {
      Post: Prisma.$PostPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      createdAt: Date
      updateAt: Date
      alias: string
      image: string | null
    }, ExtArgs["result"]["treatmentType"]>
    composites: {}
  }

  type TreatmentTypeGetPayload<S extends boolean | null | undefined | TreatmentTypeDefaultArgs> = $Result.GetResult<Prisma.$TreatmentTypePayload, S>

  type TreatmentTypeCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<TreatmentTypeFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: TreatmentTypeCountAggregateInputType | true
    }

  export interface TreatmentTypeDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['TreatmentType'], meta: { name: 'TreatmentType' } }
    /**
     * Find zero or one TreatmentType that matches the filter.
     * @param {TreatmentTypeFindUniqueArgs} args - Arguments to find a TreatmentType
     * @example
     * // Get one TreatmentType
     * const treatmentType = await prisma.treatmentType.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends TreatmentTypeFindUniqueArgs>(args: SelectSubset<T, TreatmentTypeFindUniqueArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one TreatmentType that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {TreatmentTypeFindUniqueOrThrowArgs} args - Arguments to find a TreatmentType
     * @example
     * // Get one TreatmentType
     * const treatmentType = await prisma.treatmentType.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends TreatmentTypeFindUniqueOrThrowArgs>(args: SelectSubset<T, TreatmentTypeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first TreatmentType that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeFindFirstArgs} args - Arguments to find a TreatmentType
     * @example
     * // Get one TreatmentType
     * const treatmentType = await prisma.treatmentType.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends TreatmentTypeFindFirstArgs>(args?: SelectSubset<T, TreatmentTypeFindFirstArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first TreatmentType that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeFindFirstOrThrowArgs} args - Arguments to find a TreatmentType
     * @example
     * // Get one TreatmentType
     * const treatmentType = await prisma.treatmentType.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends TreatmentTypeFindFirstOrThrowArgs>(args?: SelectSubset<T, TreatmentTypeFindFirstOrThrowArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more TreatmentTypes that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all TreatmentTypes
     * const treatmentTypes = await prisma.treatmentType.findMany()
     * 
     * // Get first 10 TreatmentTypes
     * const treatmentTypes = await prisma.treatmentType.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const treatmentTypeWithIdOnly = await prisma.treatmentType.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends TreatmentTypeFindManyArgs>(args?: SelectSubset<T, TreatmentTypeFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a TreatmentType.
     * @param {TreatmentTypeCreateArgs} args - Arguments to create a TreatmentType.
     * @example
     * // Create one TreatmentType
     * const TreatmentType = await prisma.treatmentType.create({
     *   data: {
     *     // ... data to create a TreatmentType
     *   }
     * })
     * 
     */
    create<T extends TreatmentTypeCreateArgs>(args: SelectSubset<T, TreatmentTypeCreateArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many TreatmentTypes.
     * @param {TreatmentTypeCreateManyArgs} args - Arguments to create many TreatmentTypes.
     * @example
     * // Create many TreatmentTypes
     * const treatmentType = await prisma.treatmentType.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends TreatmentTypeCreateManyArgs>(args?: SelectSubset<T, TreatmentTypeCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a TreatmentType.
     * @param {TreatmentTypeDeleteArgs} args - Arguments to delete one TreatmentType.
     * @example
     * // Delete one TreatmentType
     * const TreatmentType = await prisma.treatmentType.delete({
     *   where: {
     *     // ... filter to delete one TreatmentType
     *   }
     * })
     * 
     */
    delete<T extends TreatmentTypeDeleteArgs>(args: SelectSubset<T, TreatmentTypeDeleteArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one TreatmentType.
     * @param {TreatmentTypeUpdateArgs} args - Arguments to update one TreatmentType.
     * @example
     * // Update one TreatmentType
     * const treatmentType = await prisma.treatmentType.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TreatmentTypeUpdateArgs>(args: SelectSubset<T, TreatmentTypeUpdateArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more TreatmentTypes.
     * @param {TreatmentTypeDeleteManyArgs} args - Arguments to filter TreatmentTypes to delete.
     * @example
     * // Delete a few TreatmentTypes
     * const { count } = await prisma.treatmentType.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends TreatmentTypeDeleteManyArgs>(args?: SelectSubset<T, TreatmentTypeDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more TreatmentTypes.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many TreatmentTypes
     * const treatmentType = await prisma.treatmentType.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends TreatmentTypeUpdateManyArgs>(args: SelectSubset<T, TreatmentTypeUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one TreatmentType.
     * @param {TreatmentTypeUpsertArgs} args - Arguments to update or create a TreatmentType.
     * @example
     * // Update or create a TreatmentType
     * const treatmentType = await prisma.treatmentType.upsert({
     *   create: {
     *     // ... data to create a TreatmentType
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the TreatmentType we want to update
     *   }
     * })
     */
    upsert<T extends TreatmentTypeUpsertArgs>(args: SelectSubset<T, TreatmentTypeUpsertArgs<ExtArgs>>): Prisma__TreatmentTypeClient<$Result.GetResult<Prisma.$TreatmentTypePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of TreatmentTypes.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeCountArgs} args - Arguments to filter TreatmentTypes to count.
     * @example
     * // Count the number of TreatmentTypes
     * const count = await prisma.treatmentType.count({
     *   where: {
     *     // ... the filter for the TreatmentTypes we want to count
     *   }
     * })
    **/
    count<T extends TreatmentTypeCountArgs>(
      args?: Subset<T, TreatmentTypeCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], TreatmentTypeCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a TreatmentType.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeAggregateArgs} 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 TreatmentTypeAggregateArgs>(args: Subset<T, TreatmentTypeAggregateArgs>): Prisma.PrismaPromise<GetTreatmentTypeAggregateType<T>>

    /**
     * Group by TreatmentType.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TreatmentTypeGroupByArgs} 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 TreatmentTypeGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: TreatmentTypeGroupByArgs['orderBy'] }
        : { orderBy?: TreatmentTypeGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, TreatmentTypeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTreatmentTypeGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the TreatmentType model
   */
  readonly fields: TreatmentTypeFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for TreatmentType.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__TreatmentTypeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Post<T extends TreatmentType$PostArgs<ExtArgs> = {}>(args?: Subset<T, TreatmentType$PostArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the TreatmentType model
   */
  interface TreatmentTypeFieldRefs {
    readonly id: FieldRef<"TreatmentType", 'String'>
    readonly name: FieldRef<"TreatmentType", 'String'>
    readonly createdAt: FieldRef<"TreatmentType", 'DateTime'>
    readonly updateAt: FieldRef<"TreatmentType", 'DateTime'>
    readonly alias: FieldRef<"TreatmentType", 'String'>
    readonly image: FieldRef<"TreatmentType", 'String'>
  }
    

  // Custom InputTypes
  /**
   * TreatmentType findUnique
   */
  export type TreatmentTypeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * Filter, which TreatmentType to fetch.
     */
    where: TreatmentTypeWhereUniqueInput
  }

  /**
   * TreatmentType findUniqueOrThrow
   */
  export type TreatmentTypeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * Filter, which TreatmentType to fetch.
     */
    where: TreatmentTypeWhereUniqueInput
  }

  /**
   * TreatmentType findFirst
   */
  export type TreatmentTypeFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * Filter, which TreatmentType to fetch.
     */
    where?: TreatmentTypeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TreatmentTypes to fetch.
     */
    orderBy?: TreatmentTypeOrderByWithRelationInput | TreatmentTypeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for TreatmentTypes.
     */
    cursor?: TreatmentTypeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TreatmentTypes 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` TreatmentTypes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TreatmentTypes.
     */
    distinct?: TreatmentTypeScalarFieldEnum | TreatmentTypeScalarFieldEnum[]
  }

  /**
   * TreatmentType findFirstOrThrow
   */
  export type TreatmentTypeFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * Filter, which TreatmentType to fetch.
     */
    where?: TreatmentTypeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TreatmentTypes to fetch.
     */
    orderBy?: TreatmentTypeOrderByWithRelationInput | TreatmentTypeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for TreatmentTypes.
     */
    cursor?: TreatmentTypeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TreatmentTypes 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` TreatmentTypes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of TreatmentTypes.
     */
    distinct?: TreatmentTypeScalarFieldEnum | TreatmentTypeScalarFieldEnum[]
  }

  /**
   * TreatmentType findMany
   */
  export type TreatmentTypeFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * Filter, which TreatmentTypes to fetch.
     */
    where?: TreatmentTypeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TreatmentTypes to fetch.
     */
    orderBy?: TreatmentTypeOrderByWithRelationInput | TreatmentTypeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing TreatmentTypes.
     */
    cursor?: TreatmentTypeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TreatmentTypes 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` TreatmentTypes.
     */
    skip?: number
    distinct?: TreatmentTypeScalarFieldEnum | TreatmentTypeScalarFieldEnum[]
  }

  /**
   * TreatmentType create
   */
  export type TreatmentTypeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * The data needed to create a TreatmentType.
     */
    data: XOR<TreatmentTypeCreateInput, TreatmentTypeUncheckedCreateInput>
  }

  /**
   * TreatmentType createMany
   */
  export type TreatmentTypeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many TreatmentTypes.
     */
    data: TreatmentTypeCreateManyInput | TreatmentTypeCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * TreatmentType update
   */
  export type TreatmentTypeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * The data needed to update a TreatmentType.
     */
    data: XOR<TreatmentTypeUpdateInput, TreatmentTypeUncheckedUpdateInput>
    /**
     * Choose, which TreatmentType to update.
     */
    where: TreatmentTypeWhereUniqueInput
  }

  /**
   * TreatmentType updateMany
   */
  export type TreatmentTypeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TreatmentTypes.
     */
    data: XOR<TreatmentTypeUpdateManyMutationInput, TreatmentTypeUncheckedUpdateManyInput>
    /**
     * Filter which TreatmentTypes to update
     */
    where?: TreatmentTypeWhereInput
    /**
     * Limit how many TreatmentTypes to update.
     */
    limit?: number
  }

  /**
   * TreatmentType upsert
   */
  export type TreatmentTypeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * The filter to search for the TreatmentType to update in case it exists.
     */
    where: TreatmentTypeWhereUniqueInput
    /**
     * In case the TreatmentType found by the `where` argument doesn't exist, create a new TreatmentType with this data.
     */
    create: XOR<TreatmentTypeCreateInput, TreatmentTypeUncheckedCreateInput>
    /**
     * In case the TreatmentType was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TreatmentTypeUpdateInput, TreatmentTypeUncheckedUpdateInput>
  }

  /**
   * TreatmentType delete
   */
  export type TreatmentTypeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
    /**
     * Filter which TreatmentType to delete.
     */
    where: TreatmentTypeWhereUniqueInput
  }

  /**
   * TreatmentType deleteMany
   */
  export type TreatmentTypeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TreatmentTypes to delete
     */
    where?: TreatmentTypeWhereInput
    /**
     * Limit how many TreatmentTypes to delete.
     */
    limit?: number
  }

  /**
   * TreatmentType.Post
   */
  export type TreatmentType$PostArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Post
     */
    select?: PostSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Post
     */
    omit?: PostOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PostInclude<ExtArgs> | null
    where?: PostWhereInput
    orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[]
    cursor?: PostWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PostScalarFieldEnum | PostScalarFieldEnum[]
  }

  /**
   * TreatmentType without action
   */
  export type TreatmentTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TreatmentType
     */
    select?: TreatmentTypeSelect<ExtArgs> | null
    /**
     * Omit specific fields from the TreatmentType
     */
    omit?: TreatmentTypeOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TreatmentTypeInclude<ExtArgs> | null
  }


  /**
   * Model Schedule
   */

  export type AggregateSchedule = {
    _count: ScheduleCountAggregateOutputType | null
    _min: ScheduleMinAggregateOutputType | null
    _max: ScheduleMaxAggregateOutputType | null
  }

  export type ScheduleMinAggregateOutputType = {
    id: string | null
    postId: string | null
    createdAt: Date | null
    dateEnd: Date | null
    dateStart: Date | null
    updateAt: Date | null
  }

  export type ScheduleMaxAggregateOutputType = {
    id: string | null
    postId: string | null
    createdAt: Date | null
    dateEnd: Date | null
    dateStart: Date | null
    updateAt: Date | null
  }

  export type ScheduleCountAggregateOutputType = {
    id: number
    postId: number
    createdAt: number
    dateEnd: number
    dateStart: number
    updateAt: number
    _all: number
  }


  export type ScheduleMinAggregateInputType = {
    id?: true
    postId?: true
    createdAt?: true
    dateEnd?: true
    dateStart?: true
    updateAt?: true
  }

  export type ScheduleMaxAggregateInputType = {
    id?: true
    postId?: true
    createdAt?: true
    dateEnd?: true
    dateStart?: true
    updateAt?: true
  }

  export type ScheduleCountAggregateInputType = {
    id?: true
    postId?: true
    createdAt?: true
    dateEnd?: true
    dateStart?: true
    updateAt?: true
    _all?: true
  }

  export type ScheduleAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Schedule to aggregate.
     */
    where?: ScheduleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Schedules to fetch.
     */
    orderBy?: ScheduleOrderByWithRelationInput | ScheduleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ScheduleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Schedules 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` Schedules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Schedules
    **/
    _count?: true | ScheduleCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ScheduleMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ScheduleMaxAggregateInputType
  }

  export type GetScheduleAggregateType<T extends ScheduleAggregateArgs> = {
        [P in keyof T & keyof AggregateSchedule]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSchedule[P]>
      : GetScalarType<T[P], AggregateSchedule[P]>
  }




  export type ScheduleGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ScheduleWhereInput
    orderBy?: ScheduleOrderByWithAggregationInput | ScheduleOrderByWithAggregationInput[]
    by: ScheduleScalarFieldEnum[] | ScheduleScalarFieldEnum
    having?: ScheduleScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ScheduleCountAggregateInputType | true
    _min?: ScheduleMinAggregateInputType
    _max?: ScheduleMaxAggregateInputType
  }

  export type ScheduleGroupByOutputType = {
    id: string
    postId: string
    createdAt: Date
    dateEnd: Date
    dateStart: Date
    updateAt: Date
    _count: ScheduleCountAggregateOutputType | null
    _min: ScheduleMinAggregateOutputType | null
    _max: ScheduleMaxAggregateOutputType | null
  }

  type GetScheduleGroupByPayload<T extends ScheduleGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ScheduleGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ScheduleGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ScheduleGroupByOutputType[P]>
            : GetScalarType<T[P], ScheduleGroupByOutputType[P]>
        }
      >
    >


  export type ScheduleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    postId?: boolean
    createdAt?: boolean
    dateEnd?: boolean
    dateStart?: boolean
    updateAt?: boolean
    Appointment?: boolean | Schedule$AppointmentArgs<ExtArgs>
    post?: boolean | PostDefaultArgs<ExtArgs>
    timeslot?: boolean | Schedule$timeslotArgs<ExtArgs>
    _count?: boolean | ScheduleCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["schedule"]>



  export type ScheduleSelectScalar = {
    id?: boolean
    postId?: boolean
    createdAt?: boolean
    dateEnd?: boolean
    dateStart?: boolean
    updateAt?: boolean
  }

  export type ScheduleOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "postId" | "createdAt" | "dateEnd" | "dateStart" | "updateAt", ExtArgs["result"]["schedule"]>
  export type ScheduleInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | Schedule$AppointmentArgs<ExtArgs>
    post?: boolean | PostDefaultArgs<ExtArgs>
    timeslot?: boolean | Schedule$timeslotArgs<ExtArgs>
    _count?: boolean | ScheduleCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $SchedulePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Schedule"
    objects: {
      Appointment: Prisma.$AppointmentPayload<ExtArgs>[]
      post: Prisma.$PostPayload<ExtArgs>
      timeslot: Prisma.$TimeslotPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      postId: string
      createdAt: Date
      dateEnd: Date
      dateStart: Date
      updateAt: Date
    }, ExtArgs["result"]["schedule"]>
    composites: {}
  }

  type ScheduleGetPayload<S extends boolean | null | undefined | ScheduleDefaultArgs> = $Result.GetResult<Prisma.$SchedulePayload, S>

  type ScheduleCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<ScheduleFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: ScheduleCountAggregateInputType | true
    }

  export interface ScheduleDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Schedule'], meta: { name: 'Schedule' } }
    /**
     * Find zero or one Schedule that matches the filter.
     * @param {ScheduleFindUniqueArgs} args - Arguments to find a Schedule
     * @example
     * // Get one Schedule
     * const schedule = await prisma.schedule.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ScheduleFindUniqueArgs>(args: SelectSubset<T, ScheduleFindUniqueArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Schedule that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {ScheduleFindUniqueOrThrowArgs} args - Arguments to find a Schedule
     * @example
     * // Get one Schedule
     * const schedule = await prisma.schedule.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ScheduleFindUniqueOrThrowArgs>(args: SelectSubset<T, ScheduleFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Schedule that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleFindFirstArgs} args - Arguments to find a Schedule
     * @example
     * // Get one Schedule
     * const schedule = await prisma.schedule.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ScheduleFindFirstArgs>(args?: SelectSubset<T, ScheduleFindFirstArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Schedule that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleFindFirstOrThrowArgs} args - Arguments to find a Schedule
     * @example
     * // Get one Schedule
     * const schedule = await prisma.schedule.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ScheduleFindFirstOrThrowArgs>(args?: SelectSubset<T, ScheduleFindFirstOrThrowArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Schedules that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Schedules
     * const schedules = await prisma.schedule.findMany()
     * 
     * // Get first 10 Schedules
     * const schedules = await prisma.schedule.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const scheduleWithIdOnly = await prisma.schedule.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ScheduleFindManyArgs>(args?: SelectSubset<T, ScheduleFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Schedule.
     * @param {ScheduleCreateArgs} args - Arguments to create a Schedule.
     * @example
     * // Create one Schedule
     * const Schedule = await prisma.schedule.create({
     *   data: {
     *     // ... data to create a Schedule
     *   }
     * })
     * 
     */
    create<T extends ScheduleCreateArgs>(args: SelectSubset<T, ScheduleCreateArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Schedules.
     * @param {ScheduleCreateManyArgs} args - Arguments to create many Schedules.
     * @example
     * // Create many Schedules
     * const schedule = await prisma.schedule.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ScheduleCreateManyArgs>(args?: SelectSubset<T, ScheduleCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Schedule.
     * @param {ScheduleDeleteArgs} args - Arguments to delete one Schedule.
     * @example
     * // Delete one Schedule
     * const Schedule = await prisma.schedule.delete({
     *   where: {
     *     // ... filter to delete one Schedule
     *   }
     * })
     * 
     */
    delete<T extends ScheduleDeleteArgs>(args: SelectSubset<T, ScheduleDeleteArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Schedule.
     * @param {ScheduleUpdateArgs} args - Arguments to update one Schedule.
     * @example
     * // Update one Schedule
     * const schedule = await prisma.schedule.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ScheduleUpdateArgs>(args: SelectSubset<T, ScheduleUpdateArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Schedules.
     * @param {ScheduleDeleteManyArgs} args - Arguments to filter Schedules to delete.
     * @example
     * // Delete a few Schedules
     * const { count } = await prisma.schedule.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ScheduleDeleteManyArgs>(args?: SelectSubset<T, ScheduleDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Schedules.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Schedules
     * const schedule = await prisma.schedule.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ScheduleUpdateManyArgs>(args: SelectSubset<T, ScheduleUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Schedule.
     * @param {ScheduleUpsertArgs} args - Arguments to update or create a Schedule.
     * @example
     * // Update or create a Schedule
     * const schedule = await prisma.schedule.upsert({
     *   create: {
     *     // ... data to create a Schedule
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Schedule we want to update
     *   }
     * })
     */
    upsert<T extends ScheduleUpsertArgs>(args: SelectSubset<T, ScheduleUpsertArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Schedules.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleCountArgs} args - Arguments to filter Schedules to count.
     * @example
     * // Count the number of Schedules
     * const count = await prisma.schedule.count({
     *   where: {
     *     // ... the filter for the Schedules we want to count
     *   }
     * })
    **/
    count<T extends ScheduleCountArgs>(
      args?: Subset<T, ScheduleCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ScheduleCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Schedule.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleAggregateArgs} 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 ScheduleAggregateArgs>(args: Subset<T, ScheduleAggregateArgs>): Prisma.PrismaPromise<GetScheduleAggregateType<T>>

    /**
     * Group by Schedule.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ScheduleGroupByArgs} 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 ScheduleGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ScheduleGroupByArgs['orderBy'] }
        : { orderBy?: ScheduleGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, ScheduleGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetScheduleGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Schedule model
   */
  readonly fields: ScheduleFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Schedule.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__ScheduleClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Appointment<T extends Schedule$AppointmentArgs<ExtArgs> = {}>(args?: Subset<T, Schedule$AppointmentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    post<T extends PostDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PostDefaultArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    timeslot<T extends Schedule$timeslotArgs<ExtArgs> = {}>(args?: Subset<T, Schedule$timeslotArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Schedule model
   */
  interface ScheduleFieldRefs {
    readonly id: FieldRef<"Schedule", 'String'>
    readonly postId: FieldRef<"Schedule", 'String'>
    readonly createdAt: FieldRef<"Schedule", 'DateTime'>
    readonly dateEnd: FieldRef<"Schedule", 'DateTime'>
    readonly dateStart: FieldRef<"Schedule", 'DateTime'>
    readonly updateAt: FieldRef<"Schedule", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Schedule findUnique
   */
  export type ScheduleFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * Filter, which Schedule to fetch.
     */
    where: ScheduleWhereUniqueInput
  }

  /**
   * Schedule findUniqueOrThrow
   */
  export type ScheduleFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * Filter, which Schedule to fetch.
     */
    where: ScheduleWhereUniqueInput
  }

  /**
   * Schedule findFirst
   */
  export type ScheduleFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * Filter, which Schedule to fetch.
     */
    where?: ScheduleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Schedules to fetch.
     */
    orderBy?: ScheduleOrderByWithRelationInput | ScheduleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Schedules.
     */
    cursor?: ScheduleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Schedules 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` Schedules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Schedules.
     */
    distinct?: ScheduleScalarFieldEnum | ScheduleScalarFieldEnum[]
  }

  /**
   * Schedule findFirstOrThrow
   */
  export type ScheduleFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * Filter, which Schedule to fetch.
     */
    where?: ScheduleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Schedules to fetch.
     */
    orderBy?: ScheduleOrderByWithRelationInput | ScheduleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Schedules.
     */
    cursor?: ScheduleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Schedules 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` Schedules.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Schedules.
     */
    distinct?: ScheduleScalarFieldEnum | ScheduleScalarFieldEnum[]
  }

  /**
   * Schedule findMany
   */
  export type ScheduleFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * Filter, which Schedules to fetch.
     */
    where?: ScheduleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Schedules to fetch.
     */
    orderBy?: ScheduleOrderByWithRelationInput | ScheduleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Schedules.
     */
    cursor?: ScheduleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Schedules 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` Schedules.
     */
    skip?: number
    distinct?: ScheduleScalarFieldEnum | ScheduleScalarFieldEnum[]
  }

  /**
   * Schedule create
   */
  export type ScheduleCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * The data needed to create a Schedule.
     */
    data: XOR<ScheduleCreateInput, ScheduleUncheckedCreateInput>
  }

  /**
   * Schedule createMany
   */
  export type ScheduleCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Schedules.
     */
    data: ScheduleCreateManyInput | ScheduleCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Schedule update
   */
  export type ScheduleUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * The data needed to update a Schedule.
     */
    data: XOR<ScheduleUpdateInput, ScheduleUncheckedUpdateInput>
    /**
     * Choose, which Schedule to update.
     */
    where: ScheduleWhereUniqueInput
  }

  /**
   * Schedule updateMany
   */
  export type ScheduleUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Schedules.
     */
    data: XOR<ScheduleUpdateManyMutationInput, ScheduleUncheckedUpdateManyInput>
    /**
     * Filter which Schedules to update
     */
    where?: ScheduleWhereInput
    /**
     * Limit how many Schedules to update.
     */
    limit?: number
  }

  /**
   * Schedule upsert
   */
  export type ScheduleUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * The filter to search for the Schedule to update in case it exists.
     */
    where: ScheduleWhereUniqueInput
    /**
     * In case the Schedule found by the `where` argument doesn't exist, create a new Schedule with this data.
     */
    create: XOR<ScheduleCreateInput, ScheduleUncheckedCreateInput>
    /**
     * In case the Schedule was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ScheduleUpdateInput, ScheduleUncheckedUpdateInput>
  }

  /**
   * Schedule delete
   */
  export type ScheduleDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
    /**
     * Filter which Schedule to delete.
     */
    where: ScheduleWhereUniqueInput
  }

  /**
   * Schedule deleteMany
   */
  export type ScheduleDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Schedules to delete
     */
    where?: ScheduleWhereInput
    /**
     * Limit how many Schedules to delete.
     */
    limit?: number
  }

  /**
   * Schedule.Appointment
   */
  export type Schedule$AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    where?: AppointmentWhereInput
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    cursor?: AppointmentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Schedule.timeslot
   */
  export type Schedule$timeslotArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    where?: TimeslotWhereInput
    orderBy?: TimeslotOrderByWithRelationInput | TimeslotOrderByWithRelationInput[]
    cursor?: TimeslotWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TimeslotScalarFieldEnum | TimeslotScalarFieldEnum[]
  }

  /**
   * Schedule without action
   */
  export type ScheduleDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Schedule
     */
    select?: ScheduleSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Schedule
     */
    omit?: ScheduleOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ScheduleInclude<ExtArgs> | null
  }


  /**
   * Model Timeslot
   */

  export type AggregateTimeslot = {
    _count: TimeslotCountAggregateOutputType | null
    _avg: TimeslotAvgAggregateOutputType | null
    _sum: TimeslotSumAggregateOutputType | null
    _min: TimeslotMinAggregateOutputType | null
    _max: TimeslotMaxAggregateOutputType | null
  }

  export type TimeslotAvgAggregateOutputType = {
    maxParticipants: number | null
    currentParticipants: number | null
  }

  export type TimeslotSumAggregateOutputType = {
    maxParticipants: number | null
    currentParticipants: number | null
  }

  export type TimeslotMinAggregateOutputType = {
    id: string | null
    startTime: string | null
    endTime: string | null
    maxParticipants: number | null
    currentParticipants: number | null
    isAvailable: boolean | null
    scheduleId: string | null
  }

  export type TimeslotMaxAggregateOutputType = {
    id: string | null
    startTime: string | null
    endTime: string | null
    maxParticipants: number | null
    currentParticipants: number | null
    isAvailable: boolean | null
    scheduleId: string | null
  }

  export type TimeslotCountAggregateOutputType = {
    id: number
    startTime: number
    endTime: number
    maxParticipants: number
    currentParticipants: number
    isAvailable: number
    scheduleId: number
    _all: number
  }


  export type TimeslotAvgAggregateInputType = {
    maxParticipants?: true
    currentParticipants?: true
  }

  export type TimeslotSumAggregateInputType = {
    maxParticipants?: true
    currentParticipants?: true
  }

  export type TimeslotMinAggregateInputType = {
    id?: true
    startTime?: true
    endTime?: true
    maxParticipants?: true
    currentParticipants?: true
    isAvailable?: true
    scheduleId?: true
  }

  export type TimeslotMaxAggregateInputType = {
    id?: true
    startTime?: true
    endTime?: true
    maxParticipants?: true
    currentParticipants?: true
    isAvailable?: true
    scheduleId?: true
  }

  export type TimeslotCountAggregateInputType = {
    id?: true
    startTime?: true
    endTime?: true
    maxParticipants?: true
    currentParticipants?: true
    isAvailable?: true
    scheduleId?: true
    _all?: true
  }

  export type TimeslotAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Timeslot to aggregate.
     */
    where?: TimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Timeslots to fetch.
     */
    orderBy?: TimeslotOrderByWithRelationInput | TimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Timeslots 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` Timeslots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Timeslots
    **/
    _count?: true | TimeslotCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TimeslotAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TimeslotSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TimeslotMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TimeslotMaxAggregateInputType
  }

  export type GetTimeslotAggregateType<T extends TimeslotAggregateArgs> = {
        [P in keyof T & keyof AggregateTimeslot]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateTimeslot[P]>
      : GetScalarType<T[P], AggregateTimeslot[P]>
  }




  export type TimeslotGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TimeslotWhereInput
    orderBy?: TimeslotOrderByWithAggregationInput | TimeslotOrderByWithAggregationInput[]
    by: TimeslotScalarFieldEnum[] | TimeslotScalarFieldEnum
    having?: TimeslotScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TimeslotCountAggregateInputType | true
    _avg?: TimeslotAvgAggregateInputType
    _sum?: TimeslotSumAggregateInputType
    _min?: TimeslotMinAggregateInputType
    _max?: TimeslotMaxAggregateInputType
  }

  export type TimeslotGroupByOutputType = {
    id: string
    startTime: string
    endTime: string
    maxParticipants: number | null
    currentParticipants: number
    isAvailable: boolean
    scheduleId: string
    _count: TimeslotCountAggregateOutputType | null
    _avg: TimeslotAvgAggregateOutputType | null
    _sum: TimeslotSumAggregateOutputType | null
    _min: TimeslotMinAggregateOutputType | null
    _max: TimeslotMaxAggregateOutputType | null
  }

  type GetTimeslotGroupByPayload<T extends TimeslotGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<TimeslotGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof TimeslotGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], TimeslotGroupByOutputType[P]>
            : GetScalarType<T[P], TimeslotGroupByOutputType[P]>
        }
      >
    >


  export type TimeslotSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    startTime?: boolean
    endTime?: boolean
    maxParticipants?: boolean
    currentParticipants?: boolean
    isAvailable?: boolean
    scheduleId?: boolean
    Appointment?: boolean | Timeslot$AppointmentArgs<ExtArgs>
    schedule?: boolean | ScheduleDefaultArgs<ExtArgs>
    _count?: boolean | TimeslotCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["timeslot"]>



  export type TimeslotSelectScalar = {
    id?: boolean
    startTime?: boolean
    endTime?: boolean
    maxParticipants?: boolean
    currentParticipants?: boolean
    isAvailable?: boolean
    scheduleId?: boolean
  }

  export type TimeslotOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "startTime" | "endTime" | "maxParticipants" | "currentParticipants" | "isAvailable" | "scheduleId", ExtArgs["result"]["timeslot"]>
  export type TimeslotInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Appointment?: boolean | Timeslot$AppointmentArgs<ExtArgs>
    schedule?: boolean | ScheduleDefaultArgs<ExtArgs>
    _count?: boolean | TimeslotCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $TimeslotPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Timeslot"
    objects: {
      Appointment: Prisma.$AppointmentPayload<ExtArgs>[]
      schedule: Prisma.$SchedulePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      startTime: string
      endTime: string
      maxParticipants: number | null
      currentParticipants: number
      isAvailable: boolean
      scheduleId: string
    }, ExtArgs["result"]["timeslot"]>
    composites: {}
  }

  type TimeslotGetPayload<S extends boolean | null | undefined | TimeslotDefaultArgs> = $Result.GetResult<Prisma.$TimeslotPayload, S>

  type TimeslotCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<TimeslotFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: TimeslotCountAggregateInputType | true
    }

  export interface TimeslotDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Timeslot'], meta: { name: 'Timeslot' } }
    /**
     * Find zero or one Timeslot that matches the filter.
     * @param {TimeslotFindUniqueArgs} args - Arguments to find a Timeslot
     * @example
     * // Get one Timeslot
     * const timeslot = await prisma.timeslot.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends TimeslotFindUniqueArgs>(args: SelectSubset<T, TimeslotFindUniqueArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Timeslot that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {TimeslotFindUniqueOrThrowArgs} args - Arguments to find a Timeslot
     * @example
     * // Get one Timeslot
     * const timeslot = await prisma.timeslot.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends TimeslotFindUniqueOrThrowArgs>(args: SelectSubset<T, TimeslotFindUniqueOrThrowArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Timeslot that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotFindFirstArgs} args - Arguments to find a Timeslot
     * @example
     * // Get one Timeslot
     * const timeslot = await prisma.timeslot.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends TimeslotFindFirstArgs>(args?: SelectSubset<T, TimeslotFindFirstArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Timeslot that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotFindFirstOrThrowArgs} args - Arguments to find a Timeslot
     * @example
     * // Get one Timeslot
     * const timeslot = await prisma.timeslot.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends TimeslotFindFirstOrThrowArgs>(args?: SelectSubset<T, TimeslotFindFirstOrThrowArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Timeslots that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Timeslots
     * const timeslots = await prisma.timeslot.findMany()
     * 
     * // Get first 10 Timeslots
     * const timeslots = await prisma.timeslot.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const timeslotWithIdOnly = await prisma.timeslot.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends TimeslotFindManyArgs>(args?: SelectSubset<T, TimeslotFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Timeslot.
     * @param {TimeslotCreateArgs} args - Arguments to create a Timeslot.
     * @example
     * // Create one Timeslot
     * const Timeslot = await prisma.timeslot.create({
     *   data: {
     *     // ... data to create a Timeslot
     *   }
     * })
     * 
     */
    create<T extends TimeslotCreateArgs>(args: SelectSubset<T, TimeslotCreateArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Timeslots.
     * @param {TimeslotCreateManyArgs} args - Arguments to create many Timeslots.
     * @example
     * // Create many Timeslots
     * const timeslot = await prisma.timeslot.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends TimeslotCreateManyArgs>(args?: SelectSubset<T, TimeslotCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Timeslot.
     * @param {TimeslotDeleteArgs} args - Arguments to delete one Timeslot.
     * @example
     * // Delete one Timeslot
     * const Timeslot = await prisma.timeslot.delete({
     *   where: {
     *     // ... filter to delete one Timeslot
     *   }
     * })
     * 
     */
    delete<T extends TimeslotDeleteArgs>(args: SelectSubset<T, TimeslotDeleteArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Timeslot.
     * @param {TimeslotUpdateArgs} args - Arguments to update one Timeslot.
     * @example
     * // Update one Timeslot
     * const timeslot = await prisma.timeslot.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TimeslotUpdateArgs>(args: SelectSubset<T, TimeslotUpdateArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Timeslots.
     * @param {TimeslotDeleteManyArgs} args - Arguments to filter Timeslots to delete.
     * @example
     * // Delete a few Timeslots
     * const { count } = await prisma.timeslot.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends TimeslotDeleteManyArgs>(args?: SelectSubset<T, TimeslotDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Timeslots.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Timeslots
     * const timeslot = await prisma.timeslot.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends TimeslotUpdateManyArgs>(args: SelectSubset<T, TimeslotUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Timeslot.
     * @param {TimeslotUpsertArgs} args - Arguments to update or create a Timeslot.
     * @example
     * // Update or create a Timeslot
     * const timeslot = await prisma.timeslot.upsert({
     *   create: {
     *     // ... data to create a Timeslot
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Timeslot we want to update
     *   }
     * })
     */
    upsert<T extends TimeslotUpsertArgs>(args: SelectSubset<T, TimeslotUpsertArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Timeslots.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotCountArgs} args - Arguments to filter Timeslots to count.
     * @example
     * // Count the number of Timeslots
     * const count = await prisma.timeslot.count({
     *   where: {
     *     // ... the filter for the Timeslots we want to count
     *   }
     * })
    **/
    count<T extends TimeslotCountArgs>(
      args?: Subset<T, TimeslotCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], TimeslotCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Timeslot.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotAggregateArgs} 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 TimeslotAggregateArgs>(args: Subset<T, TimeslotAggregateArgs>): Prisma.PrismaPromise<GetTimeslotAggregateType<T>>

    /**
     * Group by Timeslot.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TimeslotGroupByArgs} 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 TimeslotGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: TimeslotGroupByArgs['orderBy'] }
        : { orderBy?: TimeslotGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, TimeslotGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTimeslotGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Timeslot model
   */
  readonly fields: TimeslotFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Timeslot.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__TimeslotClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Appointment<T extends Timeslot$AppointmentArgs<ExtArgs> = {}>(args?: Subset<T, Timeslot$AppointmentArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    schedule<T extends ScheduleDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ScheduleDefaultArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Timeslot model
   */
  interface TimeslotFieldRefs {
    readonly id: FieldRef<"Timeslot", 'String'>
    readonly startTime: FieldRef<"Timeslot", 'String'>
    readonly endTime: FieldRef<"Timeslot", 'String'>
    readonly maxParticipants: FieldRef<"Timeslot", 'Int'>
    readonly currentParticipants: FieldRef<"Timeslot", 'Int'>
    readonly isAvailable: FieldRef<"Timeslot", 'Boolean'>
    readonly scheduleId: FieldRef<"Timeslot", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Timeslot findUnique
   */
  export type TimeslotFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * Filter, which Timeslot to fetch.
     */
    where: TimeslotWhereUniqueInput
  }

  /**
   * Timeslot findUniqueOrThrow
   */
  export type TimeslotFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * Filter, which Timeslot to fetch.
     */
    where: TimeslotWhereUniqueInput
  }

  /**
   * Timeslot findFirst
   */
  export type TimeslotFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * Filter, which Timeslot to fetch.
     */
    where?: TimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Timeslots to fetch.
     */
    orderBy?: TimeslotOrderByWithRelationInput | TimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Timeslots.
     */
    cursor?: TimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Timeslots 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` Timeslots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Timeslots.
     */
    distinct?: TimeslotScalarFieldEnum | TimeslotScalarFieldEnum[]
  }

  /**
   * Timeslot findFirstOrThrow
   */
  export type TimeslotFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * Filter, which Timeslot to fetch.
     */
    where?: TimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Timeslots to fetch.
     */
    orderBy?: TimeslotOrderByWithRelationInput | TimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Timeslots.
     */
    cursor?: TimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Timeslots 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` Timeslots.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Timeslots.
     */
    distinct?: TimeslotScalarFieldEnum | TimeslotScalarFieldEnum[]
  }

  /**
   * Timeslot findMany
   */
  export type TimeslotFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * Filter, which Timeslots to fetch.
     */
    where?: TimeslotWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Timeslots to fetch.
     */
    orderBy?: TimeslotOrderByWithRelationInput | TimeslotOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Timeslots.
     */
    cursor?: TimeslotWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Timeslots 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` Timeslots.
     */
    skip?: number
    distinct?: TimeslotScalarFieldEnum | TimeslotScalarFieldEnum[]
  }

  /**
   * Timeslot create
   */
  export type TimeslotCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * The data needed to create a Timeslot.
     */
    data: XOR<TimeslotCreateInput, TimeslotUncheckedCreateInput>
  }

  /**
   * Timeslot createMany
   */
  export type TimeslotCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Timeslots.
     */
    data: TimeslotCreateManyInput | TimeslotCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Timeslot update
   */
  export type TimeslotUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * The data needed to update a Timeslot.
     */
    data: XOR<TimeslotUpdateInput, TimeslotUncheckedUpdateInput>
    /**
     * Choose, which Timeslot to update.
     */
    where: TimeslotWhereUniqueInput
  }

  /**
   * Timeslot updateMany
   */
  export type TimeslotUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Timeslots.
     */
    data: XOR<TimeslotUpdateManyMutationInput, TimeslotUncheckedUpdateManyInput>
    /**
     * Filter which Timeslots to update
     */
    where?: TimeslotWhereInput
    /**
     * Limit how many Timeslots to update.
     */
    limit?: number
  }

  /**
   * Timeslot upsert
   */
  export type TimeslotUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * The filter to search for the Timeslot to update in case it exists.
     */
    where: TimeslotWhereUniqueInput
    /**
     * In case the Timeslot found by the `where` argument doesn't exist, create a new Timeslot with this data.
     */
    create: XOR<TimeslotCreateInput, TimeslotUncheckedCreateInput>
    /**
     * In case the Timeslot was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TimeslotUpdateInput, TimeslotUncheckedUpdateInput>
  }

  /**
   * Timeslot delete
   */
  export type TimeslotDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
    /**
     * Filter which Timeslot to delete.
     */
    where: TimeslotWhereUniqueInput
  }

  /**
   * Timeslot deleteMany
   */
  export type TimeslotDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Timeslots to delete
     */
    where?: TimeslotWhereInput
    /**
     * Limit how many Timeslots to delete.
     */
    limit?: number
  }

  /**
   * Timeslot.Appointment
   */
  export type Timeslot$AppointmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    where?: AppointmentWhereInput
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    cursor?: AppointmentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Timeslot without action
   */
  export type TimeslotDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Timeslot
     */
    select?: TimeslotSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Timeslot
     */
    omit?: TimeslotOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TimeslotInclude<ExtArgs> | null
  }


  /**
   * Model Review
   */

  export type AggregateReview = {
    _count: ReviewCountAggregateOutputType | null
    _avg: ReviewAvgAggregateOutputType | null
    _sum: ReviewSumAggregateOutputType | null
    _min: ReviewMinAggregateOutputType | null
    _max: ReviewMaxAggregateOutputType | null
  }

  export type ReviewAvgAggregateOutputType = {
    rating: Decimal | null
  }

  export type ReviewSumAggregateOutputType = {
    rating: Decimal | null
  }

  export type ReviewMinAggregateOutputType = {
    id: string | null
    postId: string | null
    pasienId: string | null
    rating: Decimal | null
    comment: string | null
    createdAt: Date | null
    koasId: string | null
  }

  export type ReviewMaxAggregateOutputType = {
    id: string | null
    postId: string | null
    pasienId: string | null
    rating: Decimal | null
    comment: string | null
    createdAt: Date | null
    koasId: string | null
  }

  export type ReviewCountAggregateOutputType = {
    id: number
    postId: number
    pasienId: number
    rating: number
    comment: number
    createdAt: number
    koasId: number
    _all: number
  }


  export type ReviewAvgAggregateInputType = {
    rating?: true
  }

  export type ReviewSumAggregateInputType = {
    rating?: true
  }

  export type ReviewMinAggregateInputType = {
    id?: true
    postId?: true
    pasienId?: true
    rating?: true
    comment?: true
    createdAt?: true
    koasId?: true
  }

  export type ReviewMaxAggregateInputType = {
    id?: true
    postId?: true
    pasienId?: true
    rating?: true
    comment?: true
    createdAt?: true
    koasId?: true
  }

  export type ReviewCountAggregateInputType = {
    id?: true
    postId?: true
    pasienId?: true
    rating?: true
    comment?: true
    createdAt?: true
    koasId?: true
    _all?: true
  }

  export type ReviewAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Review to aggregate.
     */
    where?: ReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Reviews to fetch.
     */
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Reviews 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` Reviews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Reviews
    **/
    _count?: true | ReviewCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ReviewAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ReviewSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ReviewMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ReviewMaxAggregateInputType
  }

  export type GetReviewAggregateType<T extends ReviewAggregateArgs> = {
        [P in keyof T & keyof AggregateReview]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateReview[P]>
      : GetScalarType<T[P], AggregateReview[P]>
  }




  export type ReviewGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ReviewWhereInput
    orderBy?: ReviewOrderByWithAggregationInput | ReviewOrderByWithAggregationInput[]
    by: ReviewScalarFieldEnum[] | ReviewScalarFieldEnum
    having?: ReviewScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ReviewCountAggregateInputType | true
    _avg?: ReviewAvgAggregateInputType
    _sum?: ReviewSumAggregateInputType
    _min?: ReviewMinAggregateInputType
    _max?: ReviewMaxAggregateInputType
  }

  export type ReviewGroupByOutputType = {
    id: string
    postId: string
    pasienId: string
    rating: Decimal
    comment: string | null
    createdAt: Date
    koasId: string | null
    _count: ReviewCountAggregateOutputType | null
    _avg: ReviewAvgAggregateOutputType | null
    _sum: ReviewSumAggregateOutputType | null
    _min: ReviewMinAggregateOutputType | null
    _max: ReviewMaxAggregateOutputType | null
  }

  type GetReviewGroupByPayload<T extends ReviewGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ReviewGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ReviewGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ReviewGroupByOutputType[P]>
            : GetScalarType<T[P], ReviewGroupByOutputType[P]>
        }
      >
    >


  export type ReviewSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    postId?: boolean
    pasienId?: boolean
    rating?: boolean
    comment?: boolean
    createdAt?: boolean
    koasId?: boolean
    KoasProfile?: boolean | Review$KoasProfileArgs<ExtArgs>
    post?: boolean | PostDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["review"]>



  export type ReviewSelectScalar = {
    id?: boolean
    postId?: boolean
    pasienId?: boolean
    rating?: boolean
    comment?: boolean
    createdAt?: boolean
    koasId?: boolean
  }

  export type ReviewOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "postId" | "pasienId" | "rating" | "comment" | "createdAt" | "koasId", ExtArgs["result"]["review"]>
  export type ReviewInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    KoasProfile?: boolean | Review$KoasProfileArgs<ExtArgs>
    post?: boolean | PostDefaultArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ReviewPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Review"
    objects: {
      KoasProfile: Prisma.$KoasProfilePayload<ExtArgs> | null
      post: Prisma.$PostPayload<ExtArgs>
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      postId: string
      pasienId: string
      rating: Prisma.Decimal
      comment: string | null
      createdAt: Date
      koasId: string | null
    }, ExtArgs["result"]["review"]>
    composites: {}
  }

  type ReviewGetPayload<S extends boolean | null | undefined | ReviewDefaultArgs> = $Result.GetResult<Prisma.$ReviewPayload, S>

  type ReviewCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<ReviewFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: ReviewCountAggregateInputType | true
    }

  export interface ReviewDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Review'], meta: { name: 'Review' } }
    /**
     * Find zero or one Review that matches the filter.
     * @param {ReviewFindUniqueArgs} args - Arguments to find a Review
     * @example
     * // Get one Review
     * const review = await prisma.review.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ReviewFindUniqueArgs>(args: SelectSubset<T, ReviewFindUniqueArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Review that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {ReviewFindUniqueOrThrowArgs} args - Arguments to find a Review
     * @example
     * // Get one Review
     * const review = await prisma.review.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ReviewFindUniqueOrThrowArgs>(args: SelectSubset<T, ReviewFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Review that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewFindFirstArgs} args - Arguments to find a Review
     * @example
     * // Get one Review
     * const review = await prisma.review.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ReviewFindFirstArgs>(args?: SelectSubset<T, ReviewFindFirstArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Review that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewFindFirstOrThrowArgs} args - Arguments to find a Review
     * @example
     * // Get one Review
     * const review = await prisma.review.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ReviewFindFirstOrThrowArgs>(args?: SelectSubset<T, ReviewFindFirstOrThrowArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Reviews that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Reviews
     * const reviews = await prisma.review.findMany()
     * 
     * // Get first 10 Reviews
     * const reviews = await prisma.review.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const reviewWithIdOnly = await prisma.review.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ReviewFindManyArgs>(args?: SelectSubset<T, ReviewFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Review.
     * @param {ReviewCreateArgs} args - Arguments to create a Review.
     * @example
     * // Create one Review
     * const Review = await prisma.review.create({
     *   data: {
     *     // ... data to create a Review
     *   }
     * })
     * 
     */
    create<T extends ReviewCreateArgs>(args: SelectSubset<T, ReviewCreateArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Reviews.
     * @param {ReviewCreateManyArgs} args - Arguments to create many Reviews.
     * @example
     * // Create many Reviews
     * const review = await prisma.review.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ReviewCreateManyArgs>(args?: SelectSubset<T, ReviewCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Review.
     * @param {ReviewDeleteArgs} args - Arguments to delete one Review.
     * @example
     * // Delete one Review
     * const Review = await prisma.review.delete({
     *   where: {
     *     // ... filter to delete one Review
     *   }
     * })
     * 
     */
    delete<T extends ReviewDeleteArgs>(args: SelectSubset<T, ReviewDeleteArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Review.
     * @param {ReviewUpdateArgs} args - Arguments to update one Review.
     * @example
     * // Update one Review
     * const review = await prisma.review.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ReviewUpdateArgs>(args: SelectSubset<T, ReviewUpdateArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Reviews.
     * @param {ReviewDeleteManyArgs} args - Arguments to filter Reviews to delete.
     * @example
     * // Delete a few Reviews
     * const { count } = await prisma.review.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ReviewDeleteManyArgs>(args?: SelectSubset<T, ReviewDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Reviews.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Reviews
     * const review = await prisma.review.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ReviewUpdateManyArgs>(args: SelectSubset<T, ReviewUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Review.
     * @param {ReviewUpsertArgs} args - Arguments to update or create a Review.
     * @example
     * // Update or create a Review
     * const review = await prisma.review.upsert({
     *   create: {
     *     // ... data to create a Review
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Review we want to update
     *   }
     * })
     */
    upsert<T extends ReviewUpsertArgs>(args: SelectSubset<T, ReviewUpsertArgs<ExtArgs>>): Prisma__ReviewClient<$Result.GetResult<Prisma.$ReviewPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Reviews.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewCountArgs} args - Arguments to filter Reviews to count.
     * @example
     * // Count the number of Reviews
     * const count = await prisma.review.count({
     *   where: {
     *     // ... the filter for the Reviews we want to count
     *   }
     * })
    **/
    count<T extends ReviewCountArgs>(
      args?: Subset<T, ReviewCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ReviewCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Review.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewAggregateArgs} 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 ReviewAggregateArgs>(args: Subset<T, ReviewAggregateArgs>): Prisma.PrismaPromise<GetReviewAggregateType<T>>

    /**
     * Group by Review.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ReviewGroupByArgs} 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 ReviewGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ReviewGroupByArgs['orderBy'] }
        : { orderBy?: ReviewGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, ReviewGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetReviewGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Review model
   */
  readonly fields: ReviewFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Review.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__ReviewClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    KoasProfile<T extends Review$KoasProfileArgs<ExtArgs> = {}>(args?: Subset<T, Review$KoasProfileArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    post<T extends PostDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PostDefaultArgs<ExtArgs>>): Prisma__PostClient<$Result.GetResult<Prisma.$PostPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Review model
   */
  interface ReviewFieldRefs {
    readonly id: FieldRef<"Review", 'String'>
    readonly postId: FieldRef<"Review", 'String'>
    readonly pasienId: FieldRef<"Review", 'String'>
    readonly rating: FieldRef<"Review", 'Decimal'>
    readonly comment: FieldRef<"Review", 'String'>
    readonly createdAt: FieldRef<"Review", 'DateTime'>
    readonly koasId: FieldRef<"Review", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Review findUnique
   */
  export type ReviewFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * Filter, which Review to fetch.
     */
    where: ReviewWhereUniqueInput
  }

  /**
   * Review findUniqueOrThrow
   */
  export type ReviewFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * Filter, which Review to fetch.
     */
    where: ReviewWhereUniqueInput
  }

  /**
   * Review findFirst
   */
  export type ReviewFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * Filter, which Review to fetch.
     */
    where?: ReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Reviews to fetch.
     */
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Reviews.
     */
    cursor?: ReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Reviews 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` Reviews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Reviews.
     */
    distinct?: ReviewScalarFieldEnum | ReviewScalarFieldEnum[]
  }

  /**
   * Review findFirstOrThrow
   */
  export type ReviewFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * Filter, which Review to fetch.
     */
    where?: ReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Reviews to fetch.
     */
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Reviews.
     */
    cursor?: ReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Reviews 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` Reviews.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Reviews.
     */
    distinct?: ReviewScalarFieldEnum | ReviewScalarFieldEnum[]
  }

  /**
   * Review findMany
   */
  export type ReviewFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * Filter, which Reviews to fetch.
     */
    where?: ReviewWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Reviews to fetch.
     */
    orderBy?: ReviewOrderByWithRelationInput | ReviewOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Reviews.
     */
    cursor?: ReviewWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Reviews 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` Reviews.
     */
    skip?: number
    distinct?: ReviewScalarFieldEnum | ReviewScalarFieldEnum[]
  }

  /**
   * Review create
   */
  export type ReviewCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * The data needed to create a Review.
     */
    data: XOR<ReviewCreateInput, ReviewUncheckedCreateInput>
  }

  /**
   * Review createMany
   */
  export type ReviewCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Reviews.
     */
    data: ReviewCreateManyInput | ReviewCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Review update
   */
  export type ReviewUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * The data needed to update a Review.
     */
    data: XOR<ReviewUpdateInput, ReviewUncheckedUpdateInput>
    /**
     * Choose, which Review to update.
     */
    where: ReviewWhereUniqueInput
  }

  /**
   * Review updateMany
   */
  export type ReviewUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Reviews.
     */
    data: XOR<ReviewUpdateManyMutationInput, ReviewUncheckedUpdateManyInput>
    /**
     * Filter which Reviews to update
     */
    where?: ReviewWhereInput
    /**
     * Limit how many Reviews to update.
     */
    limit?: number
  }

  /**
   * Review upsert
   */
  export type ReviewUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * The filter to search for the Review to update in case it exists.
     */
    where: ReviewWhereUniqueInput
    /**
     * In case the Review found by the `where` argument doesn't exist, create a new Review with this data.
     */
    create: XOR<ReviewCreateInput, ReviewUncheckedCreateInput>
    /**
     * In case the Review was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ReviewUpdateInput, ReviewUncheckedUpdateInput>
  }

  /**
   * Review delete
   */
  export type ReviewDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
    /**
     * Filter which Review to delete.
     */
    where: ReviewWhereUniqueInput
  }

  /**
   * Review deleteMany
   */
  export type ReviewDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Reviews to delete
     */
    where?: ReviewWhereInput
    /**
     * Limit how many Reviews to delete.
     */
    limit?: number
  }

  /**
   * Review.KoasProfile
   */
  export type Review$KoasProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the KoasProfile
     */
    select?: KoasProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the KoasProfile
     */
    omit?: KoasProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: KoasProfileInclude<ExtArgs> | null
    where?: KoasProfileWhereInput
  }

  /**
   * Review without action
   */
  export type ReviewDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Review
     */
    select?: ReviewSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Review
     */
    omit?: ReviewOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ReviewInclude<ExtArgs> | null
  }


  /**
   * Model Appointment
   */

  export type AggregateAppointment = {
    _count: AppointmentCountAggregateOutputType | null
    _min: AppointmentMinAggregateOutputType | null
    _max: AppointmentMaxAggregateOutputType | null
  }

  export type AppointmentMinAggregateOutputType = {
    id: string | null
    pasienId: string | null
    koasId: string | null
    scheduleId: string | null
    timeslotId: string | null
    date: string | null
    status: $Enums.StatusAppointment | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AppointmentMaxAggregateOutputType = {
    id: string | null
    pasienId: string | null
    koasId: string | null
    scheduleId: string | null
    timeslotId: string | null
    date: string | null
    status: $Enums.StatusAppointment | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type AppointmentCountAggregateOutputType = {
    id: number
    pasienId: number
    koasId: number
    scheduleId: number
    timeslotId: number
    date: number
    status: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type AppointmentMinAggregateInputType = {
    id?: true
    pasienId?: true
    koasId?: true
    scheduleId?: true
    timeslotId?: true
    date?: true
    status?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AppointmentMaxAggregateInputType = {
    id?: true
    pasienId?: true
    koasId?: true
    scheduleId?: true
    timeslotId?: true
    date?: true
    status?: true
    createdAt?: true
    updatedAt?: true
  }

  export type AppointmentCountAggregateInputType = {
    id?: true
    pasienId?: true
    koasId?: true
    scheduleId?: true
    timeslotId?: true
    date?: true
    status?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type AppointmentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Appointment to aggregate.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments 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` Appointments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Appointments
    **/
    _count?: true | AppointmentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AppointmentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AppointmentMaxAggregateInputType
  }

  export type GetAppointmentAggregateType<T extends AppointmentAggregateArgs> = {
        [P in keyof T & keyof AggregateAppointment]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAppointment[P]>
      : GetScalarType<T[P], AggregateAppointment[P]>
  }




  export type AppointmentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppointmentWhereInput
    orderBy?: AppointmentOrderByWithAggregationInput | AppointmentOrderByWithAggregationInput[]
    by: AppointmentScalarFieldEnum[] | AppointmentScalarFieldEnum
    having?: AppointmentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppointmentCountAggregateInputType | true
    _min?: AppointmentMinAggregateInputType
    _max?: AppointmentMaxAggregateInputType
  }

  export type AppointmentGroupByOutputType = {
    id: string
    pasienId: string
    koasId: string
    scheduleId: string
    timeslotId: string
    date: string
    status: $Enums.StatusAppointment
    createdAt: Date
    updatedAt: Date
    _count: AppointmentCountAggregateOutputType | null
    _min: AppointmentMinAggregateOutputType | null
    _max: AppointmentMaxAggregateOutputType | null
  }

  type GetAppointmentGroupByPayload<T extends AppointmentGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<AppointmentGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof AppointmentGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], AppointmentGroupByOutputType[P]>
            : GetScalarType<T[P], AppointmentGroupByOutputType[P]>
        }
      >
    >


  export type AppointmentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    pasienId?: boolean
    koasId?: boolean
    scheduleId?: boolean
    timeslotId?: boolean
    date?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    koas?: boolean | KoasProfileDefaultArgs<ExtArgs>
    pasien?: boolean | PasienProfileDefaultArgs<ExtArgs>
    schedule?: boolean | ScheduleDefaultArgs<ExtArgs>
    timeslot?: boolean | TimeslotDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["appointment"]>



  export type AppointmentSelectScalar = {
    id?: boolean
    pasienId?: boolean
    koasId?: boolean
    scheduleId?: boolean
    timeslotId?: boolean
    date?: boolean
    status?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type AppointmentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "pasienId" | "koasId" | "scheduleId" | "timeslotId" | "date" | "status" | "createdAt" | "updatedAt", ExtArgs["result"]["appointment"]>
  export type AppointmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    koas?: boolean | KoasProfileDefaultArgs<ExtArgs>
    pasien?: boolean | PasienProfileDefaultArgs<ExtArgs>
    schedule?: boolean | ScheduleDefaultArgs<ExtArgs>
    timeslot?: boolean | TimeslotDefaultArgs<ExtArgs>
  }

  export type $AppointmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Appointment"
    objects: {
      koas: Prisma.$KoasProfilePayload<ExtArgs>
      pasien: Prisma.$PasienProfilePayload<ExtArgs>
      schedule: Prisma.$SchedulePayload<ExtArgs>
      timeslot: Prisma.$TimeslotPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      pasienId: string
      koasId: string
      scheduleId: string
      timeslotId: string
      date: string
      status: $Enums.StatusAppointment
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["appointment"]>
    composites: {}
  }

  type AppointmentGetPayload<S extends boolean | null | undefined | AppointmentDefaultArgs> = $Result.GetResult<Prisma.$AppointmentPayload, S>

  type AppointmentCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AppointmentFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AppointmentCountAggregateInputType | true
    }

  export interface AppointmentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Appointment'], meta: { name: 'Appointment' } }
    /**
     * Find zero or one Appointment that matches the filter.
     * @param {AppointmentFindUniqueArgs} args - Arguments to find a Appointment
     * @example
     * // Get one Appointment
     * const appointment = await prisma.appointment.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends AppointmentFindUniqueArgs>(args: SelectSubset<T, AppointmentFindUniqueArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Appointment that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {AppointmentFindUniqueOrThrowArgs} args - Arguments to find a Appointment
     * @example
     * // Get one Appointment
     * const appointment = await prisma.appointment.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends AppointmentFindUniqueOrThrowArgs>(args: SelectSubset<T, AppointmentFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Appointment that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentFindFirstArgs} args - Arguments to find a Appointment
     * @example
     * // Get one Appointment
     * const appointment = await prisma.appointment.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AppointmentFindFirstArgs>(args?: SelectSubset<T, AppointmentFindFirstArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Appointment that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentFindFirstOrThrowArgs} args - Arguments to find a Appointment
     * @example
     * // Get one Appointment
     * const appointment = await prisma.appointment.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AppointmentFindFirstOrThrowArgs>(args?: SelectSubset<T, AppointmentFindFirstOrThrowArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Appointments that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Appointments
     * const appointments = await prisma.appointment.findMany()
     * 
     * // Get first 10 Appointments
     * const appointments = await prisma.appointment.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const appointmentWithIdOnly = await prisma.appointment.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends AppointmentFindManyArgs>(args?: SelectSubset<T, AppointmentFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Appointment.
     * @param {AppointmentCreateArgs} args - Arguments to create a Appointment.
     * @example
     * // Create one Appointment
     * const Appointment = await prisma.appointment.create({
     *   data: {
     *     // ... data to create a Appointment
     *   }
     * })
     * 
     */
    create<T extends AppointmentCreateArgs>(args: SelectSubset<T, AppointmentCreateArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Appointments.
     * @param {AppointmentCreateManyArgs} args - Arguments to create many Appointments.
     * @example
     * // Create many Appointments
     * const appointment = await prisma.appointment.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends AppointmentCreateManyArgs>(args?: SelectSubset<T, AppointmentCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Appointment.
     * @param {AppointmentDeleteArgs} args - Arguments to delete one Appointment.
     * @example
     * // Delete one Appointment
     * const Appointment = await prisma.appointment.delete({
     *   where: {
     *     // ... filter to delete one Appointment
     *   }
     * })
     * 
     */
    delete<T extends AppointmentDeleteArgs>(args: SelectSubset<T, AppointmentDeleteArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Appointment.
     * @param {AppointmentUpdateArgs} args - Arguments to update one Appointment.
     * @example
     * // Update one Appointment
     * const appointment = await prisma.appointment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AppointmentUpdateArgs>(args: SelectSubset<T, AppointmentUpdateArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Appointments.
     * @param {AppointmentDeleteManyArgs} args - Arguments to filter Appointments to delete.
     * @example
     * // Delete a few Appointments
     * const { count } = await prisma.appointment.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends AppointmentDeleteManyArgs>(args?: SelectSubset<T, AppointmentDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Appointments.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Appointments
     * const appointment = await prisma.appointment.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends AppointmentUpdateManyArgs>(args: SelectSubset<T, AppointmentUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Appointment.
     * @param {AppointmentUpsertArgs} args - Arguments to update or create a Appointment.
     * @example
     * // Update or create a Appointment
     * const appointment = await prisma.appointment.upsert({
     *   create: {
     *     // ... data to create a Appointment
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Appointment we want to update
     *   }
     * })
     */
    upsert<T extends AppointmentUpsertArgs>(args: SelectSubset<T, AppointmentUpsertArgs<ExtArgs>>): Prisma__AppointmentClient<$Result.GetResult<Prisma.$AppointmentPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Appointments.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentCountArgs} args - Arguments to filter Appointments to count.
     * @example
     * // Count the number of Appointments
     * const count = await prisma.appointment.count({
     *   where: {
     *     // ... the filter for the Appointments we want to count
     *   }
     * })
    **/
    count<T extends AppointmentCountArgs>(
      args?: Subset<T, AppointmentCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], AppointmentCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Appointment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentAggregateArgs} 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 AppointmentAggregateArgs>(args: Subset<T, AppointmentAggregateArgs>): Prisma.PrismaPromise<GetAppointmentAggregateType<T>>

    /**
     * Group by Appointment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AppointmentGroupByArgs} 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 AppointmentGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AppointmentGroupByArgs['orderBy'] }
        : { orderBy?: AppointmentGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, AppointmentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAppointmentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Appointment model
   */
  readonly fields: AppointmentFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Appointment.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__AppointmentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    koas<T extends KoasProfileDefaultArgs<ExtArgs> = {}>(args?: Subset<T, KoasProfileDefaultArgs<ExtArgs>>): Prisma__KoasProfileClient<$Result.GetResult<Prisma.$KoasProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    pasien<T extends PasienProfileDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PasienProfileDefaultArgs<ExtArgs>>): Prisma__PasienProfileClient<$Result.GetResult<Prisma.$PasienProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    schedule<T extends ScheduleDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ScheduleDefaultArgs<ExtArgs>>): Prisma__ScheduleClient<$Result.GetResult<Prisma.$SchedulePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    timeslot<T extends TimeslotDefaultArgs<ExtArgs> = {}>(args?: Subset<T, TimeslotDefaultArgs<ExtArgs>>): Prisma__TimeslotClient<$Result.GetResult<Prisma.$TimeslotPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Appointment model
   */
  interface AppointmentFieldRefs {
    readonly id: FieldRef<"Appointment", 'String'>
    readonly pasienId: FieldRef<"Appointment", 'String'>
    readonly koasId: FieldRef<"Appointment", 'String'>
    readonly scheduleId: FieldRef<"Appointment", 'String'>
    readonly timeslotId: FieldRef<"Appointment", 'String'>
    readonly date: FieldRef<"Appointment", 'String'>
    readonly status: FieldRef<"Appointment", 'StatusAppointment'>
    readonly createdAt: FieldRef<"Appointment", 'DateTime'>
    readonly updatedAt: FieldRef<"Appointment", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Appointment findUnique
   */
  export type AppointmentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment findUniqueOrThrow
   */
  export type AppointmentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment findFirst
   */
  export type AppointmentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Appointments.
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments 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` Appointments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Appointments.
     */
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Appointment findFirstOrThrow
   */
  export type AppointmentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointment to fetch.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Appointments.
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments 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` Appointments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Appointments.
     */
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Appointment findMany
   */
  export type AppointmentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter, which Appointments to fetch.
     */
    where?: AppointmentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Appointments to fetch.
     */
    orderBy?: AppointmentOrderByWithRelationInput | AppointmentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Appointments.
     */
    cursor?: AppointmentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Appointments 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` Appointments.
     */
    skip?: number
    distinct?: AppointmentScalarFieldEnum | AppointmentScalarFieldEnum[]
  }

  /**
   * Appointment create
   */
  export type AppointmentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The data needed to create a Appointment.
     */
    data: XOR<AppointmentCreateInput, AppointmentUncheckedCreateInput>
  }

  /**
   * Appointment createMany
   */
  export type AppointmentCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Appointments.
     */
    data: AppointmentCreateManyInput | AppointmentCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Appointment update
   */
  export type AppointmentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The data needed to update a Appointment.
     */
    data: XOR<AppointmentUpdateInput, AppointmentUncheckedUpdateInput>
    /**
     * Choose, which Appointment to update.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment updateMany
   */
  export type AppointmentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Appointments.
     */
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyInput>
    /**
     * Filter which Appointments to update
     */
    where?: AppointmentWhereInput
    /**
     * Limit how many Appointments to update.
     */
    limit?: number
  }

  /**
   * Appointment upsert
   */
  export type AppointmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * The filter to search for the Appointment to update in case it exists.
     */
    where: AppointmentWhereUniqueInput
    /**
     * In case the Appointment found by the `where` argument doesn't exist, create a new Appointment with this data.
     */
    create: XOR<AppointmentCreateInput, AppointmentUncheckedCreateInput>
    /**
     * In case the Appointment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppointmentUpdateInput, AppointmentUncheckedUpdateInput>
  }

  /**
   * Appointment delete
   */
  export type AppointmentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
    /**
     * Filter which Appointment to delete.
     */
    where: AppointmentWhereUniqueInput
  }

  /**
   * Appointment deleteMany
   */
  export type AppointmentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Appointments to delete
     */
    where?: AppointmentWhereInput
    /**
     * Limit how many Appointments to delete.
     */
    limit?: number
  }

  /**
   * Appointment without action
   */
  export type AppointmentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Appointment
     */
    select?: AppointmentSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Appointment
     */
    omit?: AppointmentOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AppointmentInclude<ExtArgs> | null
  }


  /**
   * Model verificationrequest
   */

  export type AggregateVerificationrequest = {
    _count: VerificationrequestCountAggregateOutputType | null
    _min: VerificationrequestMinAggregateOutputType | null
    _max: VerificationrequestMaxAggregateOutputType | null
  }

  export type VerificationrequestMinAggregateOutputType = {
    id: string | null
    token: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
    email: string | null
  }

  export type VerificationrequestMaxAggregateOutputType = {
    id: string | null
    token: string | null
    expires: Date | null
    createdAt: Date | null
    updatedAt: Date | null
    email: string | null
  }

  export type VerificationrequestCountAggregateOutputType = {
    id: number
    token: number
    expires: number
    createdAt: number
    updatedAt: number
    email: number
    _all: number
  }


  export type VerificationrequestMinAggregateInputType = {
    id?: true
    token?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    email?: true
  }

  export type VerificationrequestMaxAggregateInputType = {
    id?: true
    token?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    email?: true
  }

  export type VerificationrequestCountAggregateInputType = {
    id?: true
    token?: true
    expires?: true
    createdAt?: true
    updatedAt?: true
    email?: true
    _all?: true
  }

  export type VerificationrequestAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which verificationrequest to aggregate.
     */
    where?: verificationrequestWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of verificationrequests to fetch.
     */
    orderBy?: verificationrequestOrderByWithRelationInput | verificationrequestOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: verificationrequestWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` verificationrequests 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` verificationrequests.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned verificationrequests
    **/
    _count?: true | VerificationrequestCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: VerificationrequestMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: VerificationrequestMaxAggregateInputType
  }

  export type GetVerificationrequestAggregateType<T extends VerificationrequestAggregateArgs> = {
        [P in keyof T & keyof AggregateVerificationrequest]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateVerificationrequest[P]>
      : GetScalarType<T[P], AggregateVerificationrequest[P]>
  }




  export type verificationrequestGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: verificationrequestWhereInput
    orderBy?: verificationrequestOrderByWithAggregationInput | verificationrequestOrderByWithAggregationInput[]
    by: VerificationrequestScalarFieldEnum[] | VerificationrequestScalarFieldEnum
    having?: verificationrequestScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VerificationrequestCountAggregateInputType | true
    _min?: VerificationrequestMinAggregateInputType
    _max?: VerificationrequestMaxAggregateInputType
  }

  export type VerificationrequestGroupByOutputType = {
    id: string
    token: string
    expires: Date
    createdAt: Date
    updatedAt: Date
    email: string
    _count: VerificationrequestCountAggregateOutputType | null
    _min: VerificationrequestMinAggregateOutputType | null
    _max: VerificationrequestMaxAggregateOutputType | null
  }

  type GetVerificationrequestGroupByPayload<T extends verificationrequestGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<VerificationrequestGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof VerificationrequestGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], VerificationrequestGroupByOutputType[P]>
            : GetScalarType<T[P], VerificationrequestGroupByOutputType[P]>
        }
      >
    >


  export type verificationrequestSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    token?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    email?: boolean
  }, ExtArgs["result"]["verificationrequest"]>



  export type verificationrequestSelectScalar = {
    id?: boolean
    token?: boolean
    expires?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    email?: boolean
  }

  export type verificationrequestOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "token" | "expires" | "createdAt" | "updatedAt" | "email", ExtArgs["result"]["verificationrequest"]>

  export type $verificationrequestPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "verificationrequest"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      token: string
      expires: Date
      createdAt: Date
      updatedAt: Date
      email: string
    }, ExtArgs["result"]["verificationrequest"]>
    composites: {}
  }

  type verificationrequestGetPayload<S extends boolean | null | undefined | verificationrequestDefaultArgs> = $Result.GetResult<Prisma.$verificationrequestPayload, S>

  type verificationrequestCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<verificationrequestFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: VerificationrequestCountAggregateInputType | true
    }

  export interface verificationrequestDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['verificationrequest'], meta: { name: 'verificationrequest' } }
    /**
     * Find zero or one Verificationrequest that matches the filter.
     * @param {verificationrequestFindUniqueArgs} args - Arguments to find a Verificationrequest
     * @example
     * // Get one Verificationrequest
     * const verificationrequest = await prisma.verificationrequest.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends verificationrequestFindUniqueArgs>(args: SelectSubset<T, verificationrequestFindUniqueArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find one Verificationrequest that matches the filter or throw an error with `error.code='P2025'`
     * if no matches were found.
     * @param {verificationrequestFindUniqueOrThrowArgs} args - Arguments to find a Verificationrequest
     * @example
     * // Get one Verificationrequest
     * const verificationrequest = await prisma.verificationrequest.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends verificationrequestFindUniqueOrThrowArgs>(args: SelectSubset<T, verificationrequestFindUniqueOrThrowArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Verificationrequest that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {verificationrequestFindFirstArgs} args - Arguments to find a Verificationrequest
     * @example
     * // Get one Verificationrequest
     * const verificationrequest = await prisma.verificationrequest.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends verificationrequestFindFirstArgs>(args?: SelectSubset<T, verificationrequestFindFirstArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Verificationrequest that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {verificationrequestFindFirstOrThrowArgs} args - Arguments to find a Verificationrequest
     * @example
     * // Get one Verificationrequest
     * const verificationrequest = await prisma.verificationrequest.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends verificationrequestFindFirstOrThrowArgs>(args?: SelectSubset<T, verificationrequestFindFirstOrThrowArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Verificationrequests that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {verificationrequestFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Verificationrequests
     * const verificationrequests = await prisma.verificationrequest.findMany()
     * 
     * // Get first 10 Verificationrequests
     * const verificationrequests = await prisma.verificationrequest.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const verificationrequestWithIdOnly = await prisma.verificationrequest.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends verificationrequestFindManyArgs>(args?: SelectSubset<T, verificationrequestFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Verificationrequest.
     * @param {verificationrequestCreateArgs} args - Arguments to create a Verificationrequest.
     * @example
     * // Create one Verificationrequest
     * const Verificationrequest = await prisma.verificationrequest.create({
     *   data: {
     *     // ... data to create a Verificationrequest
     *   }
     * })
     * 
     */
    create<T extends verificationrequestCreateArgs>(args: SelectSubset<T, verificationrequestCreateArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Create many Verificationrequests.
     * @param {verificationrequestCreateManyArgs} args - Arguments to create many Verificationrequests.
     * @example
     * // Create many Verificationrequests
     * const verificationrequest = await prisma.verificationrequest.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends verificationrequestCreateManyArgs>(args?: SelectSubset<T, verificationrequestCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Verificationrequest.
     * @param {verificationrequestDeleteArgs} args - Arguments to delete one Verificationrequest.
     * @example
     * // Delete one Verificationrequest
     * const Verificationrequest = await prisma.verificationrequest.delete({
     *   where: {
     *     // ... filter to delete one Verificationrequest
     *   }
     * })
     * 
     */
    delete<T extends verificationrequestDeleteArgs>(args: SelectSubset<T, verificationrequestDeleteArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Verificationrequest.
     * @param {verificationrequestUpdateArgs} args - Arguments to update one Verificationrequest.
     * @example
     * // Update one Verificationrequest
     * const verificationrequest = await prisma.verificationrequest.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends verificationrequestUpdateArgs>(args: SelectSubset<T, verificationrequestUpdateArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Delete zero or more Verificationrequests.
     * @param {verificationrequestDeleteManyArgs} args - Arguments to filter Verificationrequests to delete.
     * @example
     * // Delete a few Verificationrequests
     * const { count } = await prisma.verificationrequest.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends verificationrequestDeleteManyArgs>(args?: SelectSubset<T, verificationrequestDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Verificationrequests.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {verificationrequestUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Verificationrequests
     * const verificationrequest = await prisma.verificationrequest.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends verificationrequestUpdateManyArgs>(args: SelectSubset<T, verificationrequestUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Verificationrequest.
     * @param {verificationrequestUpsertArgs} args - Arguments to update or create a Verificationrequest.
     * @example
     * // Update or create a Verificationrequest
     * const verificationrequest = await prisma.verificationrequest.upsert({
     *   create: {
     *     // ... data to create a Verificationrequest
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Verificationrequest we want to update
     *   }
     * })
     */
    upsert<T extends verificationrequestUpsertArgs>(args: SelectSubset<T, verificationrequestUpsertArgs<ExtArgs>>): Prisma__verificationrequestClient<$Result.GetResult<Prisma.$verificationrequestPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>


    /**
     * Count the number of Verificationrequests.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {verificationrequestCountArgs} args - Arguments to filter Verificationrequests to count.
     * @example
     * // Count the number of Verificationrequests
     * const count = await prisma.verificationrequest.count({
     *   where: {
     *     // ... the filter for the Verificationrequests we want to count
     *   }
     * })
    **/
    count<T extends verificationrequestCountArgs>(
      args?: Subset<T, verificationrequestCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], VerificationrequestCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Verificationrequest.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {VerificationrequestAggregateArgs} 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 VerificationrequestAggregateArgs>(args: Subset<T, VerificationrequestAggregateArgs>): Prisma.PrismaPromise<GetVerificationrequestAggregateType<T>>

    /**
     * Group by Verificationrequest.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {verificationrequestGroupByArgs} 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 verificationrequestGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: verificationrequestGroupByArgs['orderBy'] }
        : { orderBy?: verificationrequestGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, verificationrequestGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetVerificationrequestGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the verificationrequest model
   */
  readonly fields: verificationrequestFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for verificationrequest.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__verificationrequestClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the verificationrequest model
   */
  interface verificationrequestFieldRefs {
    readonly id: FieldRef<"verificationrequest", 'String'>
    readonly token: FieldRef<"verificationrequest", 'String'>
    readonly expires: FieldRef<"verificationrequest", 'DateTime'>
    readonly createdAt: FieldRef<"verificationrequest", 'DateTime'>
    readonly updatedAt: FieldRef<"verificationrequest", 'DateTime'>
    readonly email: FieldRef<"verificationrequest", 'String'>
  }
    

  // Custom InputTypes
  /**
   * verificationrequest findUnique
   */
  export type verificationrequestFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * Filter, which verificationrequest to fetch.
     */
    where: verificationrequestWhereUniqueInput
  }

  /**
   * verificationrequest findUniqueOrThrow
   */
  export type verificationrequestFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * Filter, which verificationrequest to fetch.
     */
    where: verificationrequestWhereUniqueInput
  }

  /**
   * verificationrequest findFirst
   */
  export type verificationrequestFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * Filter, which verificationrequest to fetch.
     */
    where?: verificationrequestWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of verificationrequests to fetch.
     */
    orderBy?: verificationrequestOrderByWithRelationInput | verificationrequestOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for verificationrequests.
     */
    cursor?: verificationrequestWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` verificationrequests 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` verificationrequests.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of verificationrequests.
     */
    distinct?: VerificationrequestScalarFieldEnum | VerificationrequestScalarFieldEnum[]
  }

  /**
   * verificationrequest findFirstOrThrow
   */
  export type verificationrequestFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * Filter, which verificationrequest to fetch.
     */
    where?: verificationrequestWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of verificationrequests to fetch.
     */
    orderBy?: verificationrequestOrderByWithRelationInput | verificationrequestOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for verificationrequests.
     */
    cursor?: verificationrequestWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` verificationrequests 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` verificationrequests.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of verificationrequests.
     */
    distinct?: VerificationrequestScalarFieldEnum | VerificationrequestScalarFieldEnum[]
  }

  /**
   * verificationrequest findMany
   */
  export type verificationrequestFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * Filter, which verificationrequests to fetch.
     */
    where?: verificationrequestWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of verificationrequests to fetch.
     */
    orderBy?: verificationrequestOrderByWithRelationInput | verificationrequestOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing verificationrequests.
     */
    cursor?: verificationrequestWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` verificationrequests 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` verificationrequests.
     */
    skip?: number
    distinct?: VerificationrequestScalarFieldEnum | VerificationrequestScalarFieldEnum[]
  }

  /**
   * verificationrequest create
   */
  export type verificationrequestCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * The data needed to create a verificationrequest.
     */
    data: XOR<verificationrequestCreateInput, verificationrequestUncheckedCreateInput>
  }

  /**
   * verificationrequest createMany
   */
  export type verificationrequestCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many verificationrequests.
     */
    data: verificationrequestCreateManyInput | verificationrequestCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * verificationrequest update
   */
  export type verificationrequestUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * The data needed to update a verificationrequest.
     */
    data: XOR<verificationrequestUpdateInput, verificationrequestUncheckedUpdateInput>
    /**
     * Choose, which verificationrequest to update.
     */
    where: verificationrequestWhereUniqueInput
  }

  /**
   * verificationrequest updateMany
   */
  export type verificationrequestUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update verificationrequests.
     */
    data: XOR<verificationrequestUpdateManyMutationInput, verificationrequestUncheckedUpdateManyInput>
    /**
     * Filter which verificationrequests to update
     */
    where?: verificationrequestWhereInput
    /**
     * Limit how many verificationrequests to update.
     */
    limit?: number
  }

  /**
   * verificationrequest upsert
   */
  export type verificationrequestUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * The filter to search for the verificationrequest to update in case it exists.
     */
    where: verificationrequestWhereUniqueInput
    /**
     * In case the verificationrequest found by the `where` argument doesn't exist, create a new verificationrequest with this data.
     */
    create: XOR<verificationrequestCreateInput, verificationrequestUncheckedCreateInput>
    /**
     * In case the verificationrequest was found with the provided `where` argument, update it with this data.
     */
    update: XOR<verificationrequestUpdateInput, verificationrequestUncheckedUpdateInput>
  }

  /**
   * verificationrequest delete
   */
  export type verificationrequestDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
    /**
     * Filter which verificationrequest to delete.
     */
    where: verificationrequestWhereUniqueInput
  }

  /**
   * verificationrequest deleteMany
   */
  export type verificationrequestDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which verificationrequests to delete
     */
    where?: verificationrequestWhereInput
    /**
     * Limit how many verificationrequests to delete.
     */
    limit?: number
  }

  /**
   * verificationrequest without action
   */
  export type verificationrequestDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the verificationrequest
     */
    select?: verificationrequestSelect<ExtArgs> | null
    /**
     * Omit specific fields from the verificationrequest
     */
    omit?: verificationrequestOmit<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

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


  export const UserScalarFieldEnum: {
    id: 'id',
    name: 'name',
    email: 'email',
    emailVerified: 'emailVerified',
    password: 'password',
    phone: 'phone',
    address: 'address',
    image: 'image',
    role: 'role',
    createdAt: 'createdAt',
    updateAt: 'updateAt',
    familyName: 'familyName',
    givenName: 'givenName'
  };

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


  export const AccountScalarFieldEnum: {
    type: 'type',
    provider: 'provider',
    scope: 'scope',
    access_token: 'access_token',
    expires_at: 'expires_at',
    id_token: 'id_token',
    providerAccountId: 'providerAccountId',
    refresh_token: 'refresh_token',
    token_type: 'token_type',
    userId: 'userId',
    id: 'id',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const SessionScalarFieldEnum: {
    id: 'id',
    expires: 'expires',
    sessionToken: 'sessionToken',
    userId: 'userId',
    accessToken: 'accessToken',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const OtpScalarFieldEnum: {
    id: 'id',
    email: 'email',
    otp: 'otp',
    expires: 'expires',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const KoasProfileScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    koasNumber: 'koasNumber',
    age: 'age',
    gender: 'gender',
    departement: 'departement',
    university: 'university',
    bio: 'bio',
    whatsappLink: 'whatsappLink',
    status: 'status',
    createdAt: 'createdAt',
    updateAt: 'updateAt',
    universityId: 'universityId',
    experience: 'experience'
  };

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


  export const PasienProfileScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    age: 'age',
    gender: 'gender',
    bio: 'bio',
    createdAt: 'createdAt',
    updateAt: 'updateAt'
  };

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


  export const FasilitatorProfileScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    university: 'university'
  };

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


  export const UniversityScalarFieldEnum: {
    id: 'id',
    name: 'name',
    alias: 'alias',
    location: 'location',
    latitude: 'latitude',
    longitude: 'longitude',
    image: 'image',
    createdAt: 'createdAt',
    updateAt: 'updateAt'
  };

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


  export const PostScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    koasId: 'koasId',
    treatmentId: 'treatmentId',
    title: 'title',
    desc: 'desc',
    patientRequirement: 'patientRequirement',
    status: 'status',
    published: 'published',
    createdAt: 'createdAt',
    updateAt: 'updateAt',
    requiredParticipant: 'requiredParticipant',
    images: 'images'
  };

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


  export const LikeScalarFieldEnum: {
    id: 'id',
    postId: 'postId',
    userId: 'userId',
    createdAt: 'createdAt'
  };

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


  export const NotificationScalarFieldEnum: {
    id: 'id',
    message: 'message',
    createdAt: 'createdAt',
    koasId: 'koasId',
    senderId: 'senderId',
    status: 'status',
    title: 'title',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const TreatmentTypeScalarFieldEnum: {
    id: 'id',
    name: 'name',
    createdAt: 'createdAt',
    updateAt: 'updateAt',
    alias: 'alias',
    image: 'image'
  };

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


  export const ScheduleScalarFieldEnum: {
    id: 'id',
    postId: 'postId',
    createdAt: 'createdAt',
    dateEnd: 'dateEnd',
    dateStart: 'dateStart',
    updateAt: 'updateAt'
  };

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


  export const TimeslotScalarFieldEnum: {
    id: 'id',
    startTime: 'startTime',
    endTime: 'endTime',
    maxParticipants: 'maxParticipants',
    currentParticipants: 'currentParticipants',
    isAvailable: 'isAvailable',
    scheduleId: 'scheduleId'
  };

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


  export const ReviewScalarFieldEnum: {
    id: 'id',
    postId: 'postId',
    pasienId: 'pasienId',
    rating: 'rating',
    comment: 'comment',
    createdAt: 'createdAt',
    koasId: 'koasId'
  };

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


  export const AppointmentScalarFieldEnum: {
    id: 'id',
    pasienId: 'pasienId',
    koasId: 'koasId',
    scheduleId: 'scheduleId',
    timeslotId: 'timeslotId',
    date: 'date',
    status: 'status',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

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


  export const VerificationrequestScalarFieldEnum: {
    id: 'id',
    token: 'token',
    expires: 'expires',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt',
    email: 'email'
  };

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


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

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


  export const NullableJsonNullValueInput: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull
  };

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


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

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


  export const UserOrderByRelevanceFieldEnum: {
    id: 'id',
    name: 'name',
    email: 'email',
    password: 'password',
    phone: 'phone',
    address: 'address',
    image: 'image',
    familyName: 'familyName',
    givenName: 'givenName'
  };

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


  export const AccountOrderByRelevanceFieldEnum: {
    type: 'type',
    provider: 'provider',
    scope: 'scope',
    access_token: 'access_token',
    id_token: 'id_token',
    providerAccountId: 'providerAccountId',
    refresh_token: 'refresh_token',
    token_type: 'token_type',
    userId: 'userId',
    id: 'id'
  };

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


  export const SessionOrderByRelevanceFieldEnum: {
    id: 'id',
    sessionToken: 'sessionToken',
    userId: 'userId',
    accessToken: 'accessToken'
  };

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


  export const OtpOrderByRelevanceFieldEnum: {
    id: 'id',
    email: 'email',
    otp: 'otp'
  };

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


  export const KoasProfileOrderByRelevanceFieldEnum: {
    id: 'id',
    userId: 'userId',
    koasNumber: 'koasNumber',
    age: 'age',
    gender: 'gender',
    departement: 'departement',
    university: 'university',
    bio: 'bio',
    whatsappLink: 'whatsappLink',
    universityId: 'universityId'
  };

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


  export const PasienProfileOrderByRelevanceFieldEnum: {
    id: 'id',
    userId: 'userId',
    age: 'age',
    gender: 'gender',
    bio: 'bio'
  };

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


  export const FasilitatorProfileOrderByRelevanceFieldEnum: {
    id: 'id',
    userId: 'userId',
    university: 'university'
  };

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


  export const UniversityOrderByRelevanceFieldEnum: {
    id: 'id',
    name: 'name',
    alias: 'alias',
    location: 'location',
    image: 'image'
  };

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


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

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


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

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


  export const PostOrderByRelevanceFieldEnum: {
    id: 'id',
    userId: 'userId',
    koasId: 'koasId',
    treatmentId: 'treatmentId',
    title: 'title',
    desc: 'desc'
  };

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


  export const LikeOrderByRelevanceFieldEnum: {
    id: 'id',
    postId: 'postId',
    userId: 'userId'
  };

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


  export const NotificationOrderByRelevanceFieldEnum: {
    id: 'id',
    message: 'message',
    koasId: 'koasId',
    senderId: 'senderId',
    title: 'title',
    userId: 'userId'
  };

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


  export const TreatmentTypeOrderByRelevanceFieldEnum: {
    id: 'id',
    name: 'name',
    alias: 'alias',
    image: 'image'
  };

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


  export const ScheduleOrderByRelevanceFieldEnum: {
    id: 'id',
    postId: 'postId'
  };

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


  export const TimeslotOrderByRelevanceFieldEnum: {
    id: 'id',
    startTime: 'startTime',
    endTime: 'endTime',
    scheduleId: 'scheduleId'
  };

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


  export const ReviewOrderByRelevanceFieldEnum: {
    id: 'id',
    postId: 'postId',
    pasienId: 'pasienId',
    comment: 'comment',
    koasId: 'koasId'
  };

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


  export const AppointmentOrderByRelevanceFieldEnum: {
    id: 'id',
    pasienId: 'pasienId',
    koasId: 'koasId',
    scheduleId: 'scheduleId',
    timeslotId: 'timeslotId',
    date: 'date'
  };

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


  export const verificationrequestOrderByRelevanceFieldEnum: {
    id: 'id',
    token: 'token',
    email: 'email'
  };

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


  /**
   * Field references
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'Role'
   */
  export type EnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role'>
    


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'StatusKoas'
   */
  export type EnumStatusKoasFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'StatusKoas'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'QueryMode'
   */
  export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
    


  /**
   * Reference to a field of type 'StatusPost'
   */
  export type EnumStatusPostFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'StatusPost'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'StatusNotification'
   */
  export type EnumStatusNotificationFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'StatusNotification'>
    


  /**
   * Reference to a field of type 'Decimal'
   */
  export type DecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal'>
    


  /**
   * Reference to a field of type 'StatusAppointment'
   */
  export type EnumStatusAppointmentFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'StatusAppointment'>
    
  /**
   * Deep Input Types
   */


  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    name?: StringNullableFilter<"User"> | string | null
    email?: StringNullableFilter<"User"> | string | null
    emailVerified?: DateTimeNullableFilter<"User"> | Date | string | null
    password?: StringNullableFilter<"User"> | string | null
    phone?: StringNullableFilter<"User"> | string | null
    address?: StringNullableFilter<"User"> | string | null
    image?: StringNullableFilter<"User"> | string | null
    role?: EnumRoleNullableFilter<"User"> | $Enums.Role | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    updateAt?: DateTimeFilter<"User"> | Date | string
    familyName?: StringNullableFilter<"User"> | string | null
    givenName?: StringNullableFilter<"User"> | string | null
    Account?: AccountListRelationFilter
    FasilitatorProfile?: XOR<FasilitatorProfileNullableScalarRelationFilter, FasilitatorProfileWhereInput> | null
    KoasProfile?: XOR<KoasProfileNullableScalarRelationFilter, KoasProfileWhereInput> | null
    Like?: LikeListRelationFilter
    sender?: NotificationListRelationFilter
    recipient?: NotificationListRelationFilter
    PasienProfile?: XOR<PasienProfileNullableScalarRelationFilter, PasienProfileWhereInput> | null
    Post?: PostListRelationFilter
    Review?: ReviewListRelationFilter
    sessions?: SessionListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    emailVerified?: SortOrderInput | SortOrder
    password?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    image?: SortOrderInput | SortOrder
    role?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    familyName?: SortOrderInput | SortOrder
    givenName?: SortOrderInput | SortOrder
    Account?: AccountOrderByRelationAggregateInput
    FasilitatorProfile?: FasilitatorProfileOrderByWithRelationInput
    KoasProfile?: KoasProfileOrderByWithRelationInput
    Like?: LikeOrderByRelationAggregateInput
    sender?: NotificationOrderByRelationAggregateInput
    recipient?: NotificationOrderByRelationAggregateInput
    PasienProfile?: PasienProfileOrderByWithRelationInput
    Post?: PostOrderByRelationAggregateInput
    Review?: ReviewOrderByRelationAggregateInput
    sessions?: SessionOrderByRelationAggregateInput
    _relevance?: UserOrderByRelevanceInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    emailVerified?: DateTimeNullableFilter<"User"> | Date | string | null
    password?: StringNullableFilter<"User"> | string | null
    phone?: StringNullableFilter<"User"> | string | null
    address?: StringNullableFilter<"User"> | string | null
    image?: StringNullableFilter<"User"> | string | null
    role?: EnumRoleNullableFilter<"User"> | $Enums.Role | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    updateAt?: DateTimeFilter<"User"> | Date | string
    familyName?: StringNullableFilter<"User"> | string | null
    givenName?: StringNullableFilter<"User"> | string | null
    Account?: AccountListRelationFilter
    FasilitatorProfile?: XOR<FasilitatorProfileNullableScalarRelationFilter, FasilitatorProfileWhereInput> | null
    KoasProfile?: XOR<KoasProfileNullableScalarRelationFilter, KoasProfileWhereInput> | null
    Like?: LikeListRelationFilter
    sender?: NotificationListRelationFilter
    recipient?: NotificationListRelationFilter
    PasienProfile?: XOR<PasienProfileNullableScalarRelationFilter, PasienProfileWhereInput> | null
    Post?: PostListRelationFilter
    Review?: ReviewListRelationFilter
    sessions?: SessionListRelationFilter
  }, "id" | "name" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    email?: SortOrderInput | SortOrder
    emailVerified?: SortOrderInput | SortOrder
    password?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    image?: SortOrderInput | SortOrder
    role?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    familyName?: SortOrderInput | SortOrder
    givenName?: SortOrderInput | SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    name?: StringNullableWithAggregatesFilter<"User"> | string | null
    email?: StringNullableWithAggregatesFilter<"User"> | string | null
    emailVerified?: DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
    password?: StringNullableWithAggregatesFilter<"User"> | string | null
    phone?: StringNullableWithAggregatesFilter<"User"> | string | null
    address?: StringNullableWithAggregatesFilter<"User"> | string | null
    image?: StringNullableWithAggregatesFilter<"User"> | string | null
    role?: EnumRoleNullableWithAggregatesFilter<"User"> | $Enums.Role | null
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    familyName?: StringNullableWithAggregatesFilter<"User"> | string | null
    givenName?: StringNullableWithAggregatesFilter<"User"> | string | null
  }

  export type AccountWhereInput = {
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    type?: StringNullableFilter<"Account"> | string | null
    provider?: StringFilter<"Account"> | string
    scope?: StringNullableFilter<"Account"> | string | null
    access_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    id_token?: StringNullableFilter<"Account"> | string | null
    providerAccountId?: StringFilter<"Account"> | string
    refresh_token?: StringNullableFilter<"Account"> | string | null
    token_type?: StringNullableFilter<"Account"> | string | null
    userId?: StringFilter<"Account"> | string
    id?: StringFilter<"Account"> | string
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AccountOrderByWithRelationInput = {
    type?: SortOrderInput | SortOrder
    provider?: SortOrder
    scope?: SortOrderInput | SortOrder
    access_token?: SortOrderInput | SortOrder
    expires_at?: SortOrderInput | SortOrder
    id_token?: SortOrderInput | SortOrder
    providerAccountId?: SortOrder
    refresh_token?: SortOrderInput | SortOrder
    token_type?: SortOrderInput | SortOrder
    userId?: SortOrder
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    _relevance?: AccountOrderByRelevanceInput
  }

  export type AccountWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    provider_providerAccountId?: AccountProviderProviderAccountIdCompoundUniqueInput
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    type?: StringNullableFilter<"Account"> | string | null
    provider?: StringFilter<"Account"> | string
    scope?: StringNullableFilter<"Account"> | string | null
    access_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    id_token?: StringNullableFilter<"Account"> | string | null
    providerAccountId?: StringFilter<"Account"> | string
    refresh_token?: StringNullableFilter<"Account"> | string | null
    token_type?: StringNullableFilter<"Account"> | string | null
    userId?: StringFilter<"Account"> | string
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "provider_providerAccountId">

  export type AccountOrderByWithAggregationInput = {
    type?: SortOrderInput | SortOrder
    provider?: SortOrder
    scope?: SortOrderInput | SortOrder
    access_token?: SortOrderInput | SortOrder
    expires_at?: SortOrderInput | SortOrder
    id_token?: SortOrderInput | SortOrder
    providerAccountId?: SortOrder
    refresh_token?: SortOrderInput | SortOrder
    token_type?: SortOrderInput | SortOrder
    userId?: SortOrder
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: AccountCountOrderByAggregateInput
    _avg?: AccountAvgOrderByAggregateInput
    _max?: AccountMaxOrderByAggregateInput
    _min?: AccountMinOrderByAggregateInput
    _sum?: AccountSumOrderByAggregateInput
  }

  export type AccountScalarWhereWithAggregatesInput = {
    AND?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    OR?: AccountScalarWhereWithAggregatesInput[]
    NOT?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    type?: StringNullableWithAggregatesFilter<"Account"> | string | null
    provider?: StringWithAggregatesFilter<"Account"> | string
    scope?: StringNullableWithAggregatesFilter<"Account"> | string | null
    access_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    expires_at?: IntNullableWithAggregatesFilter<"Account"> | number | null
    id_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    providerAccountId?: StringWithAggregatesFilter<"Account"> | string
    refresh_token?: StringNullableWithAggregatesFilter<"Account"> | string | null
    token_type?: StringNullableWithAggregatesFilter<"Account"> | string | null
    userId?: StringWithAggregatesFilter<"Account"> | string
    id?: StringWithAggregatesFilter<"Account"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
  }

  export type SessionWhereInput = {
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    id?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringNullableFilter<"Session"> | string | null
    accessToken?: StringNullableFilter<"Session"> | string | null
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }

  export type SessionOrderByWithRelationInput = {
    id?: SortOrder
    expires?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrderInput | SortOrder
    accessToken?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    user?: UserOrderByWithRelationInput
    _relevance?: SessionOrderByRelevanceInput
  }

  export type SessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SessionWhereInput | SessionWhereInput[]
    OR?: SessionWhereInput[]
    NOT?: SessionWhereInput | SessionWhereInput[]
    expires?: DateTimeFilter<"Session"> | Date | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringNullableFilter<"Session"> | string | null
    accessToken?: StringNullableFilter<"Session"> | string | null
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }, "id">

  export type SessionOrderByWithAggregationInput = {
    id?: SortOrder
    expires?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrderInput | SortOrder
    accessToken?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SessionCountOrderByAggregateInput
    _max?: SessionMaxOrderByAggregateInput
    _min?: SessionMinOrderByAggregateInput
  }

  export type SessionScalarWhereWithAggregatesInput = {
    AND?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    OR?: SessionScalarWhereWithAggregatesInput[]
    NOT?: SessionScalarWhereWithAggregatesInput | SessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Session"> | string
    expires?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    sessionToken?: StringWithAggregatesFilter<"Session"> | string
    userId?: StringNullableWithAggregatesFilter<"Session"> | string | null
    accessToken?: StringNullableWithAggregatesFilter<"Session"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Session"> | Date | string
  }

  export type OtpWhereInput = {
    AND?: OtpWhereInput | OtpWhereInput[]
    OR?: OtpWhereInput[]
    NOT?: OtpWhereInput | OtpWhereInput[]
    id?: StringFilter<"Otp"> | string
    email?: StringFilter<"Otp"> | string
    otp?: StringFilter<"Otp"> | string
    expires?: DateTimeFilter<"Otp"> | Date | string
    createdAt?: DateTimeFilter<"Otp"> | Date | string
    updatedAt?: DateTimeFilter<"Otp"> | Date | string
  }

  export type OtpOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    otp?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _relevance?: OtpOrderByRelevanceInput
  }

  export type OtpWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    otp?: string
    email_otp?: OtpEmailOtpCompoundUniqueInput
    AND?: OtpWhereInput | OtpWhereInput[]
    OR?: OtpWhereInput[]
    NOT?: OtpWhereInput | OtpWhereInput[]
    email?: StringFilter<"Otp"> | string
    expires?: DateTimeFilter<"Otp"> | Date | string
    createdAt?: DateTimeFilter<"Otp"> | Date | string
    updatedAt?: DateTimeFilter<"Otp"> | Date | string
  }, "id" | "otp" | "email_otp">

  export type OtpOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    otp?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: OtpCountOrderByAggregateInput
    _max?: OtpMaxOrderByAggregateInput
    _min?: OtpMinOrderByAggregateInput
  }

  export type OtpScalarWhereWithAggregatesInput = {
    AND?: OtpScalarWhereWithAggregatesInput | OtpScalarWhereWithAggregatesInput[]
    OR?: OtpScalarWhereWithAggregatesInput[]
    NOT?: OtpScalarWhereWithAggregatesInput | OtpScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Otp"> | string
    email?: StringWithAggregatesFilter<"Otp"> | string
    otp?: StringWithAggregatesFilter<"Otp"> | string
    expires?: DateTimeWithAggregatesFilter<"Otp"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"Otp"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Otp"> | Date | string
  }

  export type KoasProfileWhereInput = {
    AND?: KoasProfileWhereInput | KoasProfileWhereInput[]
    OR?: KoasProfileWhereInput[]
    NOT?: KoasProfileWhereInput | KoasProfileWhereInput[]
    id?: StringFilter<"KoasProfile"> | string
    userId?: StringFilter<"KoasProfile"> | string
    koasNumber?: StringNullableFilter<"KoasProfile"> | string | null
    age?: StringNullableFilter<"KoasProfile"> | string | null
    gender?: StringNullableFilter<"KoasProfile"> | string | null
    departement?: StringNullableFilter<"KoasProfile"> | string | null
    university?: StringNullableFilter<"KoasProfile"> | string | null
    bio?: StringNullableFilter<"KoasProfile"> | string | null
    whatsappLink?: StringNullableFilter<"KoasProfile"> | string | null
    status?: EnumStatusKoasFilter<"KoasProfile"> | $Enums.StatusKoas
    createdAt?: DateTimeFilter<"KoasProfile"> | Date | string
    updateAt?: DateTimeFilter<"KoasProfile"> | Date | string
    universityId?: StringNullableFilter<"KoasProfile"> | string | null
    experience?: IntNullableFilter<"KoasProfile"> | number | null
    Appointment?: AppointmentListRelationFilter
    University?: XOR<UniversityNullableScalarRelationFilter, UniversityWhereInput> | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    Notification?: NotificationListRelationFilter
    Post?: PostListRelationFilter
    Review?: ReviewListRelationFilter
  }

  export type KoasProfileOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    koasNumber?: SortOrderInput | SortOrder
    age?: SortOrderInput | SortOrder
    gender?: SortOrderInput | SortOrder
    departement?: SortOrderInput | SortOrder
    university?: SortOrderInput | SortOrder
    bio?: SortOrderInput | SortOrder
    whatsappLink?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    universityId?: SortOrderInput | SortOrder
    experience?: SortOrderInput | SortOrder
    Appointment?: AppointmentOrderByRelationAggregateInput
    University?: UniversityOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    Notification?: NotificationOrderByRelationAggregateInput
    Post?: PostOrderByRelationAggregateInput
    Review?: ReviewOrderByRelationAggregateInput
    _relevance?: KoasProfileOrderByRelevanceInput
  }

  export type KoasProfileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    userId?: string
    koasNumber?: string
    AND?: KoasProfileWhereInput | KoasProfileWhereInput[]
    OR?: KoasProfileWhereInput[]
    NOT?: KoasProfileWhereInput | KoasProfileWhereInput[]
    age?: StringNullableFilter<"KoasProfile"> | string | null
    gender?: StringNullableFilter<"KoasProfile"> | string | null
    departement?: StringNullableFilter<"KoasProfile"> | string | null
    university?: StringNullableFilter<"KoasProfile"> | string | null
    bio?: StringNullableFilter<"KoasProfile"> | string | null
    whatsappLink?: StringNullableFilter<"KoasProfile"> | string | null
    status?: EnumStatusKoasFilter<"KoasProfile"> | $Enums.StatusKoas
    createdAt?: DateTimeFilter<"KoasProfile"> | Date | string
    updateAt?: DateTimeFilter<"KoasProfile"> | Date | string
    universityId?: StringNullableFilter<"KoasProfile"> | string | null
    experience?: IntNullableFilter<"KoasProfile"> | number | null
    Appointment?: AppointmentListRelationFilter
    University?: XOR<UniversityNullableScalarRelationFilter, UniversityWhereInput> | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    Notification?: NotificationListRelationFilter
    Post?: PostListRelationFilter
    Review?: ReviewListRelationFilter
  }, "id" | "userId" | "koasNumber">

  export type KoasProfileOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    koasNumber?: SortOrderInput | SortOrder
    age?: SortOrderInput | SortOrder
    gender?: SortOrderInput | SortOrder
    departement?: SortOrderInput | SortOrder
    university?: SortOrderInput | SortOrder
    bio?: SortOrderInput | SortOrder
    whatsappLink?: SortOrderInput | SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    universityId?: SortOrderInput | SortOrder
    experience?: SortOrderInput | SortOrder
    _count?: KoasProfileCountOrderByAggregateInput
    _avg?: KoasProfileAvgOrderByAggregateInput
    _max?: KoasProfileMaxOrderByAggregateInput
    _min?: KoasProfileMinOrderByAggregateInput
    _sum?: KoasProfileSumOrderByAggregateInput
  }

  export type KoasProfileScalarWhereWithAggregatesInput = {
    AND?: KoasProfileScalarWhereWithAggregatesInput | KoasProfileScalarWhereWithAggregatesInput[]
    OR?: KoasProfileScalarWhereWithAggregatesInput[]
    NOT?: KoasProfileScalarWhereWithAggregatesInput | KoasProfileScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"KoasProfile"> | string
    userId?: StringWithAggregatesFilter<"KoasProfile"> | string
    koasNumber?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    age?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    gender?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    departement?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    university?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    bio?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    whatsappLink?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    status?: EnumStatusKoasWithAggregatesFilter<"KoasProfile"> | $Enums.StatusKoas
    createdAt?: DateTimeWithAggregatesFilter<"KoasProfile"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"KoasProfile"> | Date | string
    universityId?: StringNullableWithAggregatesFilter<"KoasProfile"> | string | null
    experience?: IntNullableWithAggregatesFilter<"KoasProfile"> | number | null
  }

  export type PasienProfileWhereInput = {
    AND?: PasienProfileWhereInput | PasienProfileWhereInput[]
    OR?: PasienProfileWhereInput[]
    NOT?: PasienProfileWhereInput | PasienProfileWhereInput[]
    id?: StringFilter<"PasienProfile"> | string
    userId?: StringFilter<"PasienProfile"> | string
    age?: StringNullableFilter<"PasienProfile"> | string | null
    gender?: StringNullableFilter<"PasienProfile"> | string | null
    bio?: StringNullableFilter<"PasienProfile"> | string | null
    createdAt?: DateTimeFilter<"PasienProfile"> | Date | string
    updateAt?: DateTimeFilter<"PasienProfile"> | Date | string
    Appointment?: AppointmentListRelationFilter
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type PasienProfileOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    age?: SortOrderInput | SortOrder
    gender?: SortOrderInput | SortOrder
    bio?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    Appointment?: AppointmentOrderByRelationAggregateInput
    user?: UserOrderByWithRelationInput
    _relevance?: PasienProfileOrderByRelevanceInput
  }

  export type PasienProfileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    userId?: string
    AND?: PasienProfileWhereInput | PasienProfileWhereInput[]
    OR?: PasienProfileWhereInput[]
    NOT?: PasienProfileWhereInput | PasienProfileWhereInput[]
    age?: StringNullableFilter<"PasienProfile"> | string | null
    gender?: StringNullableFilter<"PasienProfile"> | string | null
    bio?: StringNullableFilter<"PasienProfile"> | string | null
    createdAt?: DateTimeFilter<"PasienProfile"> | Date | string
    updateAt?: DateTimeFilter<"PasienProfile"> | Date | string
    Appointment?: AppointmentListRelationFilter
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type PasienProfileOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    age?: SortOrderInput | SortOrder
    gender?: SortOrderInput | SortOrder
    bio?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    _count?: PasienProfileCountOrderByAggregateInput
    _max?: PasienProfileMaxOrderByAggregateInput
    _min?: PasienProfileMinOrderByAggregateInput
  }

  export type PasienProfileScalarWhereWithAggregatesInput = {
    AND?: PasienProfileScalarWhereWithAggregatesInput | PasienProfileScalarWhereWithAggregatesInput[]
    OR?: PasienProfileScalarWhereWithAggregatesInput[]
    NOT?: PasienProfileScalarWhereWithAggregatesInput | PasienProfileScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PasienProfile"> | string
    userId?: StringWithAggregatesFilter<"PasienProfile"> | string
    age?: StringNullableWithAggregatesFilter<"PasienProfile"> | string | null
    gender?: StringNullableWithAggregatesFilter<"PasienProfile"> | string | null
    bio?: StringNullableWithAggregatesFilter<"PasienProfile"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"PasienProfile"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"PasienProfile"> | Date | string
  }

  export type FasilitatorProfileWhereInput = {
    AND?: FasilitatorProfileWhereInput | FasilitatorProfileWhereInput[]
    OR?: FasilitatorProfileWhereInput[]
    NOT?: FasilitatorProfileWhereInput | FasilitatorProfileWhereInput[]
    id?: StringFilter<"FasilitatorProfile"> | string
    userId?: StringFilter<"FasilitatorProfile"> | string
    university?: StringNullableFilter<"FasilitatorProfile"> | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type FasilitatorProfileOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    university?: SortOrderInput | SortOrder
    user?: UserOrderByWithRelationInput
    _relevance?: FasilitatorProfileOrderByRelevanceInput
  }

  export type FasilitatorProfileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    userId?: string
    AND?: FasilitatorProfileWhereInput | FasilitatorProfileWhereInput[]
    OR?: FasilitatorProfileWhereInput[]
    NOT?: FasilitatorProfileWhereInput | FasilitatorProfileWhereInput[]
    university?: StringNullableFilter<"FasilitatorProfile"> | string | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "userId">

  export type FasilitatorProfileOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    university?: SortOrderInput | SortOrder
    _count?: FasilitatorProfileCountOrderByAggregateInput
    _max?: FasilitatorProfileMaxOrderByAggregateInput
    _min?: FasilitatorProfileMinOrderByAggregateInput
  }

  export type FasilitatorProfileScalarWhereWithAggregatesInput = {
    AND?: FasilitatorProfileScalarWhereWithAggregatesInput | FasilitatorProfileScalarWhereWithAggregatesInput[]
    OR?: FasilitatorProfileScalarWhereWithAggregatesInput[]
    NOT?: FasilitatorProfileScalarWhereWithAggregatesInput | FasilitatorProfileScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"FasilitatorProfile"> | string
    userId?: StringWithAggregatesFilter<"FasilitatorProfile"> | string
    university?: StringNullableWithAggregatesFilter<"FasilitatorProfile"> | string | null
  }

  export type UniversityWhereInput = {
    AND?: UniversityWhereInput | UniversityWhereInput[]
    OR?: UniversityWhereInput[]
    NOT?: UniversityWhereInput | UniversityWhereInput[]
    id?: StringFilter<"University"> | string
    name?: StringFilter<"University"> | string
    alias?: StringFilter<"University"> | string
    location?: StringFilter<"University"> | string
    latitude?: FloatNullableFilter<"University"> | number | null
    longitude?: FloatNullableFilter<"University"> | number | null
    image?: StringNullableFilter<"University"> | string | null
    createdAt?: DateTimeFilter<"University"> | Date | string
    updateAt?: DateTimeFilter<"University"> | Date | string
    koasProfile?: KoasProfileListRelationFilter
  }

  export type UniversityOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    alias?: SortOrder
    location?: SortOrder
    latitude?: SortOrderInput | SortOrder
    longitude?: SortOrderInput | SortOrder
    image?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    koasProfile?: KoasProfileOrderByRelationAggregateInput
    _relevance?: UniversityOrderByRelevanceInput
  }

  export type UniversityWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UniversityWhereInput | UniversityWhereInput[]
    OR?: UniversityWhereInput[]
    NOT?: UniversityWhereInput | UniversityWhereInput[]
    name?: StringFilter<"University"> | string
    alias?: StringFilter<"University"> | string
    location?: StringFilter<"University"> | string
    latitude?: FloatNullableFilter<"University"> | number | null
    longitude?: FloatNullableFilter<"University"> | number | null
    image?: StringNullableFilter<"University"> | string | null
    createdAt?: DateTimeFilter<"University"> | Date | string
    updateAt?: DateTimeFilter<"University"> | Date | string
    koasProfile?: KoasProfileListRelationFilter
  }, "id">

  export type UniversityOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    alias?: SortOrder
    location?: SortOrder
    latitude?: SortOrderInput | SortOrder
    longitude?: SortOrderInput | SortOrder
    image?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    _count?: UniversityCountOrderByAggregateInput
    _avg?: UniversityAvgOrderByAggregateInput
    _max?: UniversityMaxOrderByAggregateInput
    _min?: UniversityMinOrderByAggregateInput
    _sum?: UniversitySumOrderByAggregateInput
  }

  export type UniversityScalarWhereWithAggregatesInput = {
    AND?: UniversityScalarWhereWithAggregatesInput | UniversityScalarWhereWithAggregatesInput[]
    OR?: UniversityScalarWhereWithAggregatesInput[]
    NOT?: UniversityScalarWhereWithAggregatesInput | UniversityScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"University"> | string
    name?: StringWithAggregatesFilter<"University"> | string
    alias?: StringWithAggregatesFilter<"University"> | string
    location?: StringWithAggregatesFilter<"University"> | string
    latitude?: FloatNullableWithAggregatesFilter<"University"> | number | null
    longitude?: FloatNullableWithAggregatesFilter<"University"> | number | null
    image?: StringNullableWithAggregatesFilter<"University"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"University"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"University"> | Date | string
  }

  export type PostWhereInput = {
    AND?: PostWhereInput | PostWhereInput[]
    OR?: PostWhereInput[]
    NOT?: PostWhereInput | PostWhereInput[]
    id?: StringFilter<"Post"> | string
    userId?: StringFilter<"Post"> | string
    koasId?: StringFilter<"Post"> | string
    treatmentId?: StringFilter<"Post"> | string
    title?: StringFilter<"Post"> | string
    desc?: StringFilter<"Post"> | string
    patientRequirement?: JsonNullableFilter<"Post">
    status?: EnumStatusPostFilter<"Post"> | $Enums.StatusPost
    published?: BoolFilter<"Post"> | boolean
    createdAt?: DateTimeFilter<"Post"> | Date | string
    updateAt?: DateTimeFilter<"Post"> | Date | string
    requiredParticipant?: IntFilter<"Post"> | number
    images?: JsonNullableFilter<"Post">
    likes?: LikeListRelationFilter
    koas?: XOR<KoasProfileScalarRelationFilter, KoasProfileWhereInput>
    treatment?: XOR<TreatmentTypeScalarRelationFilter, TreatmentTypeWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    Review?: ReviewListRelationFilter
    Schedule?: ScheduleListRelationFilter
  }

  export type PostOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrder
    koasId?: SortOrder
    treatmentId?: SortOrder
    title?: SortOrder
    desc?: SortOrder
    patientRequirement?: SortOrderInput | SortOrder
    status?: SortOrder
    published?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    requiredParticipant?: SortOrder
    images?: SortOrderInput | SortOrder
    likes?: LikeOrderByRelationAggregateInput
    koas?: KoasProfileOrderByWithRelationInput
    treatment?: TreatmentTypeOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    Review?: ReviewOrderByRelationAggregateInput
    Schedule?: ScheduleOrderByRelationAggregateInput
    _relevance?: PostOrderByRelevanceInput
  }

  export type PostWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PostWhereInput | PostWhereInput[]
    OR?: PostWhereInput[]
    NOT?: PostWhereInput | PostWhereInput[]
    userId?: StringFilter<"Post"> | string
    koasId?: StringFilter<"Post"> | string
    treatmentId?: StringFilter<"Post"> | string
    title?: StringFilter<"Post"> | string
    desc?: StringFilter<"Post"> | string
    patientRequirement?: JsonNullableFilter<"Post">
    status?: EnumStatusPostFilter<"Post"> | $Enums.StatusPost
    published?: BoolFilter<"Post"> | boolean
    createdAt?: DateTimeFilter<"Post"> | Date | string
    updateAt?: DateTimeFilter<"Post"> | Date | string
    requiredParticipant?: IntFilter<"Post"> | number
    images?: JsonNullableFilter<"Post">
    likes?: LikeListRelationFilter
    koas?: XOR<KoasProfileScalarRelationFilter, KoasProfileWhereInput>
    treatment?: XOR<TreatmentTypeScalarRelationFilter, TreatmentTypeWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    Review?: ReviewListRelationFilter
    Schedule?: ScheduleListRelationFilter
  }, "id">

  export type PostOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrder
    koasId?: SortOrder
    treatmentId?: SortOrder
    title?: SortOrder
    desc?: SortOrder
    patientRequirement?: SortOrderInput | SortOrder
    status?: SortOrder
    published?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    requiredParticipant?: SortOrder
    images?: SortOrderInput | SortOrder
    _count?: PostCountOrderByAggregateInput
    _avg?: PostAvgOrderByAggregateInput
    _max?: PostMaxOrderByAggregateInput
    _min?: PostMinOrderByAggregateInput
    _sum?: PostSumOrderByAggregateInput
  }

  export type PostScalarWhereWithAggregatesInput = {
    AND?: PostScalarWhereWithAggregatesInput | PostScalarWhereWithAggregatesInput[]
    OR?: PostScalarWhereWithAggregatesInput[]
    NOT?: PostScalarWhereWithAggregatesInput | PostScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Post"> | string
    userId?: StringWithAggregatesFilter<"Post"> | string
    koasId?: StringWithAggregatesFilter<"Post"> | string
    treatmentId?: StringWithAggregatesFilter<"Post"> | string
    title?: StringWithAggregatesFilter<"Post"> | string
    desc?: StringWithAggregatesFilter<"Post"> | string
    patientRequirement?: JsonNullableWithAggregatesFilter<"Post">
    status?: EnumStatusPostWithAggregatesFilter<"Post"> | $Enums.StatusPost
    published?: BoolWithAggregatesFilter<"Post"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Post"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"Post"> | Date | string
    requiredParticipant?: IntWithAggregatesFilter<"Post"> | number
    images?: JsonNullableWithAggregatesFilter<"Post">
  }

  export type LikeWhereInput = {
    AND?: LikeWhereInput | LikeWhereInput[]
    OR?: LikeWhereInput[]
    NOT?: LikeWhereInput | LikeWhereInput[]
    id?: StringFilter<"Like"> | string
    postId?: StringFilter<"Like"> | string
    userId?: StringFilter<"Like"> | string
    createdAt?: DateTimeFilter<"Like"> | Date | string
    Post?: XOR<PostScalarRelationFilter, PostWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type LikeOrderByWithRelationInput = {
    id?: SortOrder
    postId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    Post?: PostOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    _relevance?: LikeOrderByRelevanceInput
  }

  export type LikeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: LikeWhereInput | LikeWhereInput[]
    OR?: LikeWhereInput[]
    NOT?: LikeWhereInput | LikeWhereInput[]
    postId?: StringFilter<"Like"> | string
    userId?: StringFilter<"Like"> | string
    createdAt?: DateTimeFilter<"Like"> | Date | string
    Post?: XOR<PostScalarRelationFilter, PostWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type LikeOrderByWithAggregationInput = {
    id?: SortOrder
    postId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
    _count?: LikeCountOrderByAggregateInput
    _max?: LikeMaxOrderByAggregateInput
    _min?: LikeMinOrderByAggregateInput
  }

  export type LikeScalarWhereWithAggregatesInput = {
    AND?: LikeScalarWhereWithAggregatesInput | LikeScalarWhereWithAggregatesInput[]
    OR?: LikeScalarWhereWithAggregatesInput[]
    NOT?: LikeScalarWhereWithAggregatesInput | LikeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Like"> | string
    postId?: StringWithAggregatesFilter<"Like"> | string
    userId?: StringWithAggregatesFilter<"Like"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Like"> | Date | string
  }

  export type NotificationWhereInput = {
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    id?: StringFilter<"Notification"> | string
    message?: StringFilter<"Notification"> | string
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    koasId?: StringNullableFilter<"Notification"> | string | null
    senderId?: StringNullableFilter<"Notification"> | string | null
    status?: EnumStatusNotificationFilter<"Notification"> | $Enums.StatusNotification
    title?: StringFilter<"Notification"> | string
    updatedAt?: DateTimeFilter<"Notification"> | Date | string
    userId?: StringNullableFilter<"Notification"> | string | null
    koasProfile?: XOR<KoasProfileNullableScalarRelationFilter, KoasProfileWhereInput> | null
    sender?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    recipient?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }

  export type NotificationOrderByWithRelationInput = {
    id?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrderInput | SortOrder
    senderId?: SortOrderInput | SortOrder
    status?: SortOrder
    title?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrderInput | SortOrder
    koasProfile?: KoasProfileOrderByWithRelationInput
    sender?: UserOrderByWithRelationInput
    recipient?: UserOrderByWithRelationInput
    _relevance?: NotificationOrderByRelevanceInput
  }

  export type NotificationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    message?: StringFilter<"Notification"> | string
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    koasId?: StringNullableFilter<"Notification"> | string | null
    senderId?: StringNullableFilter<"Notification"> | string | null
    status?: EnumStatusNotificationFilter<"Notification"> | $Enums.StatusNotification
    title?: StringFilter<"Notification"> | string
    updatedAt?: DateTimeFilter<"Notification"> | Date | string
    userId?: StringNullableFilter<"Notification"> | string | null
    koasProfile?: XOR<KoasProfileNullableScalarRelationFilter, KoasProfileWhereInput> | null
    sender?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    recipient?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }, "id">

  export type NotificationOrderByWithAggregationInput = {
    id?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrderInput | SortOrder
    senderId?: SortOrderInput | SortOrder
    status?: SortOrder
    title?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrderInput | SortOrder
    _count?: NotificationCountOrderByAggregateInput
    _max?: NotificationMaxOrderByAggregateInput
    _min?: NotificationMinOrderByAggregateInput
  }

  export type NotificationScalarWhereWithAggregatesInput = {
    AND?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    OR?: NotificationScalarWhereWithAggregatesInput[]
    NOT?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Notification"> | string
    message?: StringWithAggregatesFilter<"Notification"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Notification"> | Date | string
    koasId?: StringNullableWithAggregatesFilter<"Notification"> | string | null
    senderId?: StringNullableWithAggregatesFilter<"Notification"> | string | null
    status?: EnumStatusNotificationWithAggregatesFilter<"Notification"> | $Enums.StatusNotification
    title?: StringWithAggregatesFilter<"Notification"> | string
    updatedAt?: DateTimeWithAggregatesFilter<"Notification"> | Date | string
    userId?: StringNullableWithAggregatesFilter<"Notification"> | string | null
  }

  export type TreatmentTypeWhereInput = {
    AND?: TreatmentTypeWhereInput | TreatmentTypeWhereInput[]
    OR?: TreatmentTypeWhereInput[]
    NOT?: TreatmentTypeWhereInput | TreatmentTypeWhereInput[]
    id?: StringFilter<"TreatmentType"> | string
    name?: StringFilter<"TreatmentType"> | string
    createdAt?: DateTimeFilter<"TreatmentType"> | Date | string
    updateAt?: DateTimeFilter<"TreatmentType"> | Date | string
    alias?: StringFilter<"TreatmentType"> | string
    image?: StringNullableFilter<"TreatmentType"> | string | null
    Post?: PostListRelationFilter
  }

  export type TreatmentTypeOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    alias?: SortOrder
    image?: SortOrderInput | SortOrder
    Post?: PostOrderByRelationAggregateInput
    _relevance?: TreatmentTypeOrderByRelevanceInput
  }

  export type TreatmentTypeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TreatmentTypeWhereInput | TreatmentTypeWhereInput[]
    OR?: TreatmentTypeWhereInput[]
    NOT?: TreatmentTypeWhereInput | TreatmentTypeWhereInput[]
    name?: StringFilter<"TreatmentType"> | string
    createdAt?: DateTimeFilter<"TreatmentType"> | Date | string
    updateAt?: DateTimeFilter<"TreatmentType"> | Date | string
    alias?: StringFilter<"TreatmentType"> | string
    image?: StringNullableFilter<"TreatmentType"> | string | null
    Post?: PostListRelationFilter
  }, "id">

  export type TreatmentTypeOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    alias?: SortOrder
    image?: SortOrderInput | SortOrder
    _count?: TreatmentTypeCountOrderByAggregateInput
    _max?: TreatmentTypeMaxOrderByAggregateInput
    _min?: TreatmentTypeMinOrderByAggregateInput
  }

  export type TreatmentTypeScalarWhereWithAggregatesInput = {
    AND?: TreatmentTypeScalarWhereWithAggregatesInput | TreatmentTypeScalarWhereWithAggregatesInput[]
    OR?: TreatmentTypeScalarWhereWithAggregatesInput[]
    NOT?: TreatmentTypeScalarWhereWithAggregatesInput | TreatmentTypeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"TreatmentType"> | string
    name?: StringWithAggregatesFilter<"TreatmentType"> | string
    createdAt?: DateTimeWithAggregatesFilter<"TreatmentType"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"TreatmentType"> | Date | string
    alias?: StringWithAggregatesFilter<"TreatmentType"> | string
    image?: StringNullableWithAggregatesFilter<"TreatmentType"> | string | null
  }

  export type ScheduleWhereInput = {
    AND?: ScheduleWhereInput | ScheduleWhereInput[]
    OR?: ScheduleWhereInput[]
    NOT?: ScheduleWhereInput | ScheduleWhereInput[]
    id?: StringFilter<"Schedule"> | string
    postId?: StringFilter<"Schedule"> | string
    createdAt?: DateTimeFilter<"Schedule"> | Date | string
    dateEnd?: DateTimeFilter<"Schedule"> | Date | string
    dateStart?: DateTimeFilter<"Schedule"> | Date | string
    updateAt?: DateTimeFilter<"Schedule"> | Date | string
    Appointment?: AppointmentListRelationFilter
    post?: XOR<PostScalarRelationFilter, PostWhereInput>
    timeslot?: TimeslotListRelationFilter
  }

  export type ScheduleOrderByWithRelationInput = {
    id?: SortOrder
    postId?: SortOrder
    createdAt?: SortOrder
    dateEnd?: SortOrder
    dateStart?: SortOrder
    updateAt?: SortOrder
    Appointment?: AppointmentOrderByRelationAggregateInput
    post?: PostOrderByWithRelationInput
    timeslot?: TimeslotOrderByRelationAggregateInput
    _relevance?: ScheduleOrderByRelevanceInput
  }

  export type ScheduleWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ScheduleWhereInput | ScheduleWhereInput[]
    OR?: ScheduleWhereInput[]
    NOT?: ScheduleWhereInput | ScheduleWhereInput[]
    postId?: StringFilter<"Schedule"> | string
    createdAt?: DateTimeFilter<"Schedule"> | Date | string
    dateEnd?: DateTimeFilter<"Schedule"> | Date | string
    dateStart?: DateTimeFilter<"Schedule"> | Date | string
    updateAt?: DateTimeFilter<"Schedule"> | Date | string
    Appointment?: AppointmentListRelationFilter
    post?: XOR<PostScalarRelationFilter, PostWhereInput>
    timeslot?: TimeslotListRelationFilter
  }, "id">

  export type ScheduleOrderByWithAggregationInput = {
    id?: SortOrder
    postId?: SortOrder
    createdAt?: SortOrder
    dateEnd?: SortOrder
    dateStart?: SortOrder
    updateAt?: SortOrder
    _count?: ScheduleCountOrderByAggregateInput
    _max?: ScheduleMaxOrderByAggregateInput
    _min?: ScheduleMinOrderByAggregateInput
  }

  export type ScheduleScalarWhereWithAggregatesInput = {
    AND?: ScheduleScalarWhereWithAggregatesInput | ScheduleScalarWhereWithAggregatesInput[]
    OR?: ScheduleScalarWhereWithAggregatesInput[]
    NOT?: ScheduleScalarWhereWithAggregatesInput | ScheduleScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Schedule"> | string
    postId?: StringWithAggregatesFilter<"Schedule"> | string
    createdAt?: DateTimeWithAggregatesFilter<"Schedule"> | Date | string
    dateEnd?: DateTimeWithAggregatesFilter<"Schedule"> | Date | string
    dateStart?: DateTimeWithAggregatesFilter<"Schedule"> | Date | string
    updateAt?: DateTimeWithAggregatesFilter<"Schedule"> | Date | string
  }

  export type TimeslotWhereInput = {
    AND?: TimeslotWhereInput | TimeslotWhereInput[]
    OR?: TimeslotWhereInput[]
    NOT?: TimeslotWhereInput | TimeslotWhereInput[]
    id?: StringFilter<"Timeslot"> | string
    startTime?: StringFilter<"Timeslot"> | string
    endTime?: StringFilter<"Timeslot"> | string
    maxParticipants?: IntNullableFilter<"Timeslot"> | number | null
    currentParticipants?: IntFilter<"Timeslot"> | number
    isAvailable?: BoolFilter<"Timeslot"> | boolean
    scheduleId?: StringFilter<"Timeslot"> | string
    Appointment?: AppointmentListRelationFilter
    schedule?: XOR<ScheduleScalarRelationFilter, ScheduleWhereInput>
  }

  export type TimeslotOrderByWithRelationInput = {
    id?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    maxParticipants?: SortOrderInput | SortOrder
    currentParticipants?: SortOrder
    isAvailable?: SortOrder
    scheduleId?: SortOrder
    Appointment?: AppointmentOrderByRelationAggregateInput
    schedule?: ScheduleOrderByWithRelationInput
    _relevance?: TimeslotOrderByRelevanceInput
  }

  export type TimeslotWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    unique_timeslot?: TimeslotUnique_timeslotCompoundUniqueInput
    AND?: TimeslotWhereInput | TimeslotWhereInput[]
    OR?: TimeslotWhereInput[]
    NOT?: TimeslotWhereInput | TimeslotWhereInput[]
    startTime?: StringFilter<"Timeslot"> | string
    endTime?: StringFilter<"Timeslot"> | string
    maxParticipants?: IntNullableFilter<"Timeslot"> | number | null
    currentParticipants?: IntFilter<"Timeslot"> | number
    isAvailable?: BoolFilter<"Timeslot"> | boolean
    scheduleId?: StringFilter<"Timeslot"> | string
    Appointment?: AppointmentListRelationFilter
    schedule?: XOR<ScheduleScalarRelationFilter, ScheduleWhereInput>
  }, "id" | "unique_timeslot">

  export type TimeslotOrderByWithAggregationInput = {
    id?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    maxParticipants?: SortOrderInput | SortOrder
    currentParticipants?: SortOrder
    isAvailable?: SortOrder
    scheduleId?: SortOrder
    _count?: TimeslotCountOrderByAggregateInput
    _avg?: TimeslotAvgOrderByAggregateInput
    _max?: TimeslotMaxOrderByAggregateInput
    _min?: TimeslotMinOrderByAggregateInput
    _sum?: TimeslotSumOrderByAggregateInput
  }

  export type TimeslotScalarWhereWithAggregatesInput = {
    AND?: TimeslotScalarWhereWithAggregatesInput | TimeslotScalarWhereWithAggregatesInput[]
    OR?: TimeslotScalarWhereWithAggregatesInput[]
    NOT?: TimeslotScalarWhereWithAggregatesInput | TimeslotScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Timeslot"> | string
    startTime?: StringWithAggregatesFilter<"Timeslot"> | string
    endTime?: StringWithAggregatesFilter<"Timeslot"> | string
    maxParticipants?: IntNullableWithAggregatesFilter<"Timeslot"> | number | null
    currentParticipants?: IntWithAggregatesFilter<"Timeslot"> | number
    isAvailable?: BoolWithAggregatesFilter<"Timeslot"> | boolean
    scheduleId?: StringWithAggregatesFilter<"Timeslot"> | string
  }

  export type ReviewWhereInput = {
    AND?: ReviewWhereInput | ReviewWhereInput[]
    OR?: ReviewWhereInput[]
    NOT?: ReviewWhereInput | ReviewWhereInput[]
    id?: StringFilter<"Review"> | string
    postId?: StringFilter<"Review"> | string
    pasienId?: StringFilter<"Review"> | string
    rating?: DecimalFilter<"Review"> | Decimal | DecimalJsLike | number | string
    comment?: StringNullableFilter<"Review"> | string | null
    createdAt?: DateTimeFilter<"Review"> | Date | string
    koasId?: StringNullableFilter<"Review"> | string | null
    KoasProfile?: XOR<KoasProfileNullableScalarRelationFilter, KoasProfileWhereInput> | null
    post?: XOR<PostScalarRelationFilter, PostWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type ReviewOrderByWithRelationInput = {
    id?: SortOrder
    postId?: SortOrder
    pasienId?: SortOrder
    rating?: SortOrder
    comment?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    koasId?: SortOrderInput | SortOrder
    KoasProfile?: KoasProfileOrderByWithRelationInput
    post?: PostOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
    _relevance?: ReviewOrderByRelevanceInput
  }

  export type ReviewWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ReviewWhereInput | ReviewWhereInput[]
    OR?: ReviewWhereInput[]
    NOT?: ReviewWhereInput | ReviewWhereInput[]
    postId?: StringFilter<"Review"> | string
    pasienId?: StringFilter<"Review"> | string
    rating?: DecimalFilter<"Review"> | Decimal | DecimalJsLike | number | string
    comment?: StringNullableFilter<"Review"> | string | null
    createdAt?: DateTimeFilter<"Review"> | Date | string
    koasId?: StringNullableFilter<"Review"> | string | null
    KoasProfile?: XOR<KoasProfileNullableScalarRelationFilter, KoasProfileWhereInput> | null
    post?: XOR<PostScalarRelationFilter, PostWhereInput>
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type ReviewOrderByWithAggregationInput = {
    id?: SortOrder
    postId?: SortOrder
    pasienId?: SortOrder
    rating?: SortOrder
    comment?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    koasId?: SortOrderInput | SortOrder
    _count?: ReviewCountOrderByAggregateInput
    _avg?: ReviewAvgOrderByAggregateInput
    _max?: ReviewMaxOrderByAggregateInput
    _min?: ReviewMinOrderByAggregateInput
    _sum?: ReviewSumOrderByAggregateInput
  }

  export type ReviewScalarWhereWithAggregatesInput = {
    AND?: ReviewScalarWhereWithAggregatesInput | ReviewScalarWhereWithAggregatesInput[]
    OR?: ReviewScalarWhereWithAggregatesInput[]
    NOT?: ReviewScalarWhereWithAggregatesInput | ReviewScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Review"> | string
    postId?: StringWithAggregatesFilter<"Review"> | string
    pasienId?: StringWithAggregatesFilter<"Review"> | string
    rating?: DecimalWithAggregatesFilter<"Review"> | Decimal | DecimalJsLike | number | string
    comment?: StringNullableWithAggregatesFilter<"Review"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Review"> | Date | string
    koasId?: StringNullableWithAggregatesFilter<"Review"> | string | null
  }

  export type AppointmentWhereInput = {
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    id?: StringFilter<"Appointment"> | string
    pasienId?: StringFilter<"Appointment"> | string
    koasId?: StringFilter<"Appointment"> | string
    scheduleId?: StringFilter<"Appointment"> | string
    timeslotId?: StringFilter<"Appointment"> | string
    date?: StringFilter<"Appointment"> | string
    status?: EnumStatusAppointmentFilter<"Appointment"> | $Enums.StatusAppointment
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    updatedAt?: DateTimeFilter<"Appointment"> | Date | string
    koas?: XOR<KoasProfileScalarRelationFilter, KoasProfileWhereInput>
    pasien?: XOR<PasienProfileScalarRelationFilter, PasienProfileWhereInput>
    schedule?: XOR<ScheduleScalarRelationFilter, ScheduleWhereInput>
    timeslot?: XOR<TimeslotScalarRelationFilter, TimeslotWhereInput>
  }

  export type AppointmentOrderByWithRelationInput = {
    id?: SortOrder
    pasienId?: SortOrder
    koasId?: SortOrder
    scheduleId?: SortOrder
    timeslotId?: SortOrder
    date?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    koas?: KoasProfileOrderByWithRelationInput
    pasien?: PasienProfileOrderByWithRelationInput
    schedule?: ScheduleOrderByWithRelationInput
    timeslot?: TimeslotOrderByWithRelationInput
    _relevance?: AppointmentOrderByRelevanceInput
  }

  export type AppointmentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AppointmentWhereInput | AppointmentWhereInput[]
    OR?: AppointmentWhereInput[]
    NOT?: AppointmentWhereInput | AppointmentWhereInput[]
    pasienId?: StringFilter<"Appointment"> | string
    koasId?: StringFilter<"Appointment"> | string
    scheduleId?: StringFilter<"Appointment"> | string
    timeslotId?: StringFilter<"Appointment"> | string
    date?: StringFilter<"Appointment"> | string
    status?: EnumStatusAppointmentFilter<"Appointment"> | $Enums.StatusAppointment
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    updatedAt?: DateTimeFilter<"Appointment"> | Date | string
    koas?: XOR<KoasProfileScalarRelationFilter, KoasProfileWhereInput>
    pasien?: XOR<PasienProfileScalarRelationFilter, PasienProfileWhereInput>
    schedule?: XOR<ScheduleScalarRelationFilter, ScheduleWhereInput>
    timeslot?: XOR<TimeslotScalarRelationFilter, TimeslotWhereInput>
  }, "id">

  export type AppointmentOrderByWithAggregationInput = {
    id?: SortOrder
    pasienId?: SortOrder
    koasId?: SortOrder
    scheduleId?: SortOrder
    timeslotId?: SortOrder
    date?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: AppointmentCountOrderByAggregateInput
    _max?: AppointmentMaxOrderByAggregateInput
    _min?: AppointmentMinOrderByAggregateInput
  }

  export type AppointmentScalarWhereWithAggregatesInput = {
    AND?: AppointmentScalarWhereWithAggregatesInput | AppointmentScalarWhereWithAggregatesInput[]
    OR?: AppointmentScalarWhereWithAggregatesInput[]
    NOT?: AppointmentScalarWhereWithAggregatesInput | AppointmentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Appointment"> | string
    pasienId?: StringWithAggregatesFilter<"Appointment"> | string
    koasId?: StringWithAggregatesFilter<"Appointment"> | string
    scheduleId?: StringWithAggregatesFilter<"Appointment"> | string
    timeslotId?: StringWithAggregatesFilter<"Appointment"> | string
    date?: StringWithAggregatesFilter<"Appointment"> | string
    status?: EnumStatusAppointmentWithAggregatesFilter<"Appointment"> | $Enums.StatusAppointment
    createdAt?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Appointment"> | Date | string
  }

  export type verificationrequestWhereInput = {
    AND?: verificationrequestWhereInput | verificationrequestWhereInput[]
    OR?: verificationrequestWhereInput[]
    NOT?: verificationrequestWhereInput | verificationrequestWhereInput[]
    id?: StringFilter<"verificationrequest"> | string
    token?: StringFilter<"verificationrequest"> | string
    expires?: DateTimeFilter<"verificationrequest"> | Date | string
    createdAt?: DateTimeFilter<"verificationrequest"> | Date | string
    updatedAt?: DateTimeFilter<"verificationrequest"> | Date | string
    email?: StringFilter<"verificationrequest"> | string
  }

  export type verificationrequestOrderByWithRelationInput = {
    id?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    email?: SortOrder
    _relevance?: verificationrequestOrderByRelevanceInput
  }

  export type verificationrequestWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    token?: string
    email_token?: verificationrequestEmailTokenCompoundUniqueInput
    AND?: verificationrequestWhereInput | verificationrequestWhereInput[]
    OR?: verificationrequestWhereInput[]
    NOT?: verificationrequestWhereInput | verificationrequestWhereInput[]
    expires?: DateTimeFilter<"verificationrequest"> | Date | string
    createdAt?: DateTimeFilter<"verificationrequest"> | Date | string
    updatedAt?: DateTimeFilter<"verificationrequest"> | Date | string
    email?: StringFilter<"verificationrequest"> | string
  }, "id" | "token" | "email_token">

  export type verificationrequestOrderByWithAggregationInput = {
    id?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    email?: SortOrder
    _count?: verificationrequestCountOrderByAggregateInput
    _max?: verificationrequestMaxOrderByAggregateInput
    _min?: verificationrequestMinOrderByAggregateInput
  }

  export type verificationrequestScalarWhereWithAggregatesInput = {
    AND?: verificationrequestScalarWhereWithAggregatesInput | verificationrequestScalarWhereWithAggregatesInput[]
    OR?: verificationrequestScalarWhereWithAggregatesInput[]
    NOT?: verificationrequestScalarWhereWithAggregatesInput | verificationrequestScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"verificationrequest"> | string
    token?: StringWithAggregatesFilter<"verificationrequest"> | string
    expires?: DateTimeWithAggregatesFilter<"verificationrequest"> | Date | string
    createdAt?: DateTimeWithAggregatesFilter<"verificationrequest"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"verificationrequest"> | Date | string
    email?: StringWithAggregatesFilter<"verificationrequest"> | string
  }

  export type UserCreateInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AccountCreateInput = {
    type?: string | null
    provider: string
    scope?: string | null
    access_token?: string | null
    expires_at?: number | null
    id_token?: string | null
    providerAccountId: string
    refresh_token?: string | null
    token_type?: string | null
    id?: string
    createdAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAccountInput
  }

  export type AccountUncheckedCreateInput = {
    type?: string | null
    provider: string
    scope?: string | null
    access_token?: string | null
    expires_at?: number | null
    id_token?: string | null
    providerAccountId: string
    refresh_token?: string | null
    token_type?: string | null
    userId: string
    id?: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUpdateInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAccountNestedInput
  }

  export type AccountUncheckedUpdateInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountCreateManyInput = {
    type?: string | null
    provider: string
    scope?: string | null
    access_token?: string | null
    expires_at?: number | null
    id_token?: string | null
    providerAccountId: string
    refresh_token?: string | null
    token_type?: string | null
    userId: string
    id?: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUpdateManyMutationInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateInput = {
    id?: string
    expires: Date | string
    sessionToken: string
    accessToken?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    user?: UserCreateNestedOneWithoutSessionsInput
  }

  export type SessionUncheckedCreateInput = {
    id?: string
    expires: Date | string
    sessionToken: string
    userId?: string | null
    accessToken?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneWithoutSessionsNestedInput
  }

  export type SessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionCreateManyInput = {
    id?: string
    expires: Date | string
    sessionToken: string
    userId?: string | null
    accessToken?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OtpCreateInput = {
    id?: string
    email: string
    otp: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type OtpUncheckedCreateInput = {
    id?: string
    email: string
    otp: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type OtpUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    otp?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OtpUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    otp?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OtpCreateManyInput = {
    id?: string
    email: string
    otp: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type OtpUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    otp?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OtpUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    otp?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type KoasProfileCreateInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentCreateNestedManyWithoutKoasInput
    University?: UniversityCreateNestedOneWithoutKoasProfileInput
    user: UserCreateNestedOneWithoutKoasProfileInput
    Notification?: NotificationCreateNestedManyWithoutKoasProfileInput
    Post?: PostCreateNestedManyWithoutKoasInput
    Review?: ReviewCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUncheckedCreateInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutKoasInput
    Notification?: NotificationUncheckedCreateNestedManyWithoutKoasProfileInput
    Post?: PostUncheckedCreateNestedManyWithoutKoasInput
    Review?: ReviewUncheckedCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUpdateManyWithoutKoasNestedInput
    University?: UniversityUpdateOneWithoutKoasProfileNestedInput
    user?: UserUpdateOneRequiredWithoutKoasProfileNestedInput
    Notification?: NotificationUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUpdateManyWithoutKoasNestedInput
    Review?: ReviewUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutKoasNestedInput
    Notification?: NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUncheckedUpdateManyWithoutKoasNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileCreateManyInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
  }

  export type KoasProfileUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type KoasProfileUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type PasienProfileCreateInput = {
    id?: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentCreateNestedManyWithoutPasienInput
    user: UserCreateNestedOneWithoutPasienProfileInput
  }

  export type PasienProfileUncheckedCreateInput = {
    id?: string
    userId: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutPasienInput
  }

  export type PasienProfileUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUpdateManyWithoutPasienNestedInput
    user?: UserUpdateOneRequiredWithoutPasienProfileNestedInput
  }

  export type PasienProfileUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUncheckedUpdateManyWithoutPasienNestedInput
  }

  export type PasienProfileCreateManyInput = {
    id?: string
    userId: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
  }

  export type PasienProfileUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PasienProfileUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FasilitatorProfileCreateInput = {
    id?: string
    university?: string | null
    user: UserCreateNestedOneWithoutFasilitatorProfileInput
  }

  export type FasilitatorProfileUncheckedCreateInput = {
    id?: string
    userId: string
    university?: string | null
  }

  export type FasilitatorProfileUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    university?: NullableStringFieldUpdateOperationsInput | string | null
    user?: UserUpdateOneRequiredWithoutFasilitatorProfileNestedInput
  }

  export type FasilitatorProfileUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    university?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type FasilitatorProfileCreateManyInput = {
    id?: string
    userId: string
    university?: string | null
  }

  export type FasilitatorProfileUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    university?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type FasilitatorProfileUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    university?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UniversityCreateInput = {
    id?: string
    name: string
    alias: string
    location: string
    latitude?: number | null
    longitude?: number | null
    image?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    koasProfile?: KoasProfileCreateNestedManyWithoutUniversityInput
  }

  export type UniversityUncheckedCreateInput = {
    id?: string
    name: string
    alias: string
    location: string
    latitude?: number | null
    longitude?: number | null
    image?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    koasProfile?: KoasProfileUncheckedCreateNestedManyWithoutUniversityInput
  }

  export type UniversityUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    alias?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    latitude?: NullableFloatFieldUpdateOperationsInput | number | null
    longitude?: NullableFloatFieldUpdateOperationsInput | number | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasProfile?: KoasProfileUpdateManyWithoutUniversityNestedInput
  }

  export type UniversityUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    alias?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    latitude?: NullableFloatFieldUpdateOperationsInput | number | null
    longitude?: NullableFloatFieldUpdateOperationsInput | number | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasProfile?: KoasProfileUncheckedUpdateManyWithoutUniversityNestedInput
  }

  export type UniversityCreateManyInput = {
    id?: string
    name: string
    alias: string
    location: string
    latitude?: number | null
    longitude?: number | null
    image?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
  }

  export type UniversityUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    alias?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    latitude?: NullableFloatFieldUpdateOperationsInput | number | null
    longitude?: NullableFloatFieldUpdateOperationsInput | number | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UniversityUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    alias?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    latitude?: NullableFloatFieldUpdateOperationsInput | number | null
    longitude?: NullableFloatFieldUpdateOperationsInput | number | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PostCreateInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeCreateNestedManyWithoutPostInput
    koas: KoasProfileCreateNestedOneWithoutPostInput
    treatment: TreatmentTypeCreateNestedOneWithoutPostInput
    user: UserCreateNestedOneWithoutPostInput
    Review?: ReviewCreateNestedManyWithoutPostInput
    Schedule?: ScheduleCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateInput = {
    id?: string
    userId: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedCreateNestedManyWithoutPostInput
    Review?: ReviewUncheckedCreateNestedManyWithoutPostInput
    Schedule?: ScheduleUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUpdateManyWithoutPostNestedInput
    koas?: KoasProfileUpdateOneRequiredWithoutPostNestedInput
    treatment?: TreatmentTypeUpdateOneRequiredWithoutPostNestedInput
    user?: UserUpdateOneRequiredWithoutPostNestedInput
    Review?: ReviewUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedUpdateManyWithoutPostNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUncheckedUpdateManyWithoutPostNestedInput
  }

  export type PostCreateManyInput = {
    id?: string
    userId: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type PostUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type PostUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type LikeCreateInput = {
    id?: string
    createdAt?: Date | string
    Post: PostCreateNestedOneWithoutLikesInput
    user: UserCreateNestedOneWithoutLikeInput
  }

  export type LikeUncheckedCreateInput = {
    id?: string
    postId: string
    userId: string
    createdAt?: Date | string
  }

  export type LikeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Post?: PostUpdateOneRequiredWithoutLikesNestedInput
    user?: UserUpdateOneRequiredWithoutLikeNestedInput
  }

  export type LikeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LikeCreateManyInput = {
    id?: string
    postId: string
    userId: string
    createdAt?: Date | string
  }

  export type LikeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LikeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationCreateInput = {
    id?: string
    message: string
    createdAt?: Date | string
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    koasProfile?: KoasProfileCreateNestedOneWithoutNotificationInput
    sender?: UserCreateNestedOneWithoutSenderInput
    recipient?: UserCreateNestedOneWithoutRecipientInput
  }

  export type NotificationUncheckedCreateInput = {
    id?: string
    message: string
    createdAt?: Date | string
    koasId?: string | null
    senderId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    userId?: string | null
  }

  export type NotificationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasProfile?: KoasProfileUpdateOneWithoutNotificationNestedInput
    sender?: UserUpdateOneWithoutSenderNestedInput
    recipient?: UserUpdateOneWithoutRecipientNestedInput
  }

  export type NotificationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
    senderId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type NotificationCreateManyInput = {
    id?: string
    message: string
    createdAt?: Date | string
    koasId?: string | null
    senderId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    userId?: string | null
  }

  export type NotificationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
    senderId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TreatmentTypeCreateInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updateAt?: Date | string
    alias: string
    image?: string | null
    Post?: PostCreateNestedManyWithoutTreatmentInput
  }

  export type TreatmentTypeUncheckedCreateInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updateAt?: Date | string
    alias: string
    image?: string | null
    Post?: PostUncheckedCreateNestedManyWithoutTreatmentInput
  }

  export type TreatmentTypeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alias?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    Post?: PostUpdateManyWithoutTreatmentNestedInput
  }

  export type TreatmentTypeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alias?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    Post?: PostUncheckedUpdateManyWithoutTreatmentNestedInput
  }

  export type TreatmentTypeCreateManyInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updateAt?: Date | string
    alias: string
    image?: string | null
  }

  export type TreatmentTypeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alias?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TreatmentTypeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alias?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ScheduleCreateInput = {
    id?: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentCreateNestedManyWithoutScheduleInput
    post: PostCreateNestedOneWithoutScheduleInput
    timeslot?: TimeslotCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleUncheckedCreateInput = {
    id?: string
    postId: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutScheduleInput
    timeslot?: TimeslotUncheckedCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUpdateManyWithoutScheduleNestedInput
    post?: PostUpdateOneRequiredWithoutScheduleNestedInput
    timeslot?: TimeslotUpdateManyWithoutScheduleNestedInput
  }

  export type ScheduleUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUncheckedUpdateManyWithoutScheduleNestedInput
    timeslot?: TimeslotUncheckedUpdateManyWithoutScheduleNestedInput
  }

  export type ScheduleCreateManyInput = {
    id?: string
    postId: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
  }

  export type ScheduleUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ScheduleUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TimeslotCreateInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    Appointment?: AppointmentCreateNestedManyWithoutTimeslotInput
    schedule: ScheduleCreateNestedOneWithoutTimeslotInput
  }

  export type TimeslotUncheckedCreateInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    scheduleId: string
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutTimeslotInput
  }

  export type TimeslotUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    Appointment?: AppointmentUpdateManyWithoutTimeslotNestedInput
    schedule?: ScheduleUpdateOneRequiredWithoutTimeslotNestedInput
  }

  export type TimeslotUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    scheduleId?: StringFieldUpdateOperationsInput | string
    Appointment?: AppointmentUncheckedUpdateManyWithoutTimeslotNestedInput
  }

  export type TimeslotCreateManyInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    scheduleId: string
  }

  export type TimeslotUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
  }

  export type TimeslotUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    scheduleId?: StringFieldUpdateOperationsInput | string
  }

  export type ReviewCreateInput = {
    id?: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    KoasProfile?: KoasProfileCreateNestedOneWithoutReviewInput
    post: PostCreateNestedOneWithoutReviewInput
    user: UserCreateNestedOneWithoutReviewInput
  }

  export type ReviewUncheckedCreateInput = {
    id?: string
    postId: string
    pasienId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    koasId?: string | null
  }

  export type ReviewUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    KoasProfile?: KoasProfileUpdateOneWithoutReviewNestedInput
    post?: PostUpdateOneRequiredWithoutReviewNestedInput
    user?: UserUpdateOneRequiredWithoutReviewNestedInput
  }

  export type ReviewUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ReviewCreateManyInput = {
    id?: string
    postId: string
    pasienId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    koasId?: string | null
  }

  export type ReviewUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ReviewUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppointmentCreateInput = {
    id?: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
    koas: KoasProfileCreateNestedOneWithoutAppointmentInput
    pasien: PasienProfileCreateNestedOneWithoutAppointmentInput
    schedule: ScheduleCreateNestedOneWithoutAppointmentInput
    timeslot: TimeslotCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateInput = {
    id?: string
    pasienId: string
    koasId: string
    scheduleId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koas?: KoasProfileUpdateOneRequiredWithoutAppointmentNestedInput
    pasien?: PasienProfileUpdateOneRequiredWithoutAppointmentNestedInput
    schedule?: ScheduleUpdateOneRequiredWithoutAppointmentNestedInput
    timeslot?: TimeslotUpdateOneRequiredWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateManyInput = {
    id?: string
    pasienId: string
    koasId: string
    scheduleId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type verificationrequestCreateInput = {
    id: string
    token: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt: Date | string
    email: string
  }

  export type verificationrequestUncheckedCreateInput = {
    id: string
    token: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt: Date | string
    email: string
  }

  export type verificationrequestUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type verificationrequestUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type verificationrequestCreateManyInput = {
    id: string
    token: string
    expires: Date | string
    createdAt?: Date | string
    updatedAt: Date | string
    email: string
  }

  export type verificationrequestUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type verificationrequestUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    token?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type EnumRoleNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.Role[] | null
    notIn?: $Enums.Role[] | null
    not?: NestedEnumRoleNullableFilter<$PrismaModel> | $Enums.Role | null
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type AccountListRelationFilter = {
    every?: AccountWhereInput
    some?: AccountWhereInput
    none?: AccountWhereInput
  }

  export type FasilitatorProfileNullableScalarRelationFilter = {
    is?: FasilitatorProfileWhereInput | null
    isNot?: FasilitatorProfileWhereInput | null
  }

  export type KoasProfileNullableScalarRelationFilter = {
    is?: KoasProfileWhereInput | null
    isNot?: KoasProfileWhereInput | null
  }

  export type LikeListRelationFilter = {
    every?: LikeWhereInput
    some?: LikeWhereInput
    none?: LikeWhereInput
  }

  export type NotificationListRelationFilter = {
    every?: NotificationWhereInput
    some?: NotificationWhereInput
    none?: NotificationWhereInput
  }

  export type PasienProfileNullableScalarRelationFilter = {
    is?: PasienProfileWhereInput | null
    isNot?: PasienProfileWhereInput | null
  }

  export type PostListRelationFilter = {
    every?: PostWhereInput
    some?: PostWhereInput
    none?: PostWhereInput
  }

  export type ReviewListRelationFilter = {
    every?: ReviewWhereInput
    some?: ReviewWhereInput
    none?: ReviewWhereInput
  }

  export type SessionListRelationFilter = {
    every?: SessionWhereInput
    some?: SessionWhereInput
    none?: SessionWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type AccountOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type LikeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NotificationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PostOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ReviewOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserOrderByRelevanceInput = {
    fields: UserOrderByRelevanceFieldEnum | UserOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    password?: SortOrder
    phone?: SortOrder
    address?: SortOrder
    image?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    familyName?: SortOrder
    givenName?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    password?: SortOrder
    phone?: SortOrder
    address?: SortOrder
    image?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    familyName?: SortOrder
    givenName?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    email?: SortOrder
    emailVerified?: SortOrder
    password?: SortOrder
    phone?: SortOrder
    address?: SortOrder
    image?: SortOrder
    role?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    familyName?: SortOrder
    givenName?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type EnumRoleNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.Role[] | null
    notIn?: $Enums.Role[] | null
    not?: NestedEnumRoleNullableWithAggregatesFilter<$PrismaModel> | $Enums.Role | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumRoleNullableFilter<$PrismaModel>
    _max?: NestedEnumRoleNullableFilter<$PrismaModel>
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type UserScalarRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type AccountOrderByRelevanceInput = {
    fields: AccountOrderByRelevanceFieldEnum | AccountOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type AccountProviderProviderAccountIdCompoundUniqueInput = {
    provider: string
    providerAccountId: string
  }

  export type AccountCountOrderByAggregateInput = {
    type?: SortOrder
    provider?: SortOrder
    scope?: SortOrder
    access_token?: SortOrder
    expires_at?: SortOrder
    id_token?: SortOrder
    providerAccountId?: SortOrder
    refresh_token?: SortOrder
    token_type?: SortOrder
    userId?: SortOrder
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountAvgOrderByAggregateInput = {
    expires_at?: SortOrder
  }

  export type AccountMaxOrderByAggregateInput = {
    type?: SortOrder
    provider?: SortOrder
    scope?: SortOrder
    access_token?: SortOrder
    expires_at?: SortOrder
    id_token?: SortOrder
    providerAccountId?: SortOrder
    refresh_token?: SortOrder
    token_type?: SortOrder
    userId?: SortOrder
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountMinOrderByAggregateInput = {
    type?: SortOrder
    provider?: SortOrder
    scope?: SortOrder
    access_token?: SortOrder
    expires_at?: SortOrder
    id_token?: SortOrder
    providerAccountId?: SortOrder
    refresh_token?: SortOrder
    token_type?: SortOrder
    userId?: SortOrder
    id?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AccountSumOrderByAggregateInput = {
    expires_at?: SortOrder
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type UserNullableScalarRelationFilter = {
    is?: UserWhereInput | null
    isNot?: UserWhereInput | null
  }

  export type SessionOrderByRelevanceInput = {
    fields: SessionOrderByRelevanceFieldEnum | SessionOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type SessionCountOrderByAggregateInput = {
    id?: SortOrder
    expires?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    accessToken?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SessionMaxOrderByAggregateInput = {
    id?: SortOrder
    expires?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    accessToken?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SessionMinOrderByAggregateInput = {
    id?: SortOrder
    expires?: SortOrder
    sessionToken?: SortOrder
    userId?: SortOrder
    accessToken?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type OtpOrderByRelevanceInput = {
    fields: OtpOrderByRelevanceFieldEnum | OtpOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type OtpEmailOtpCompoundUniqueInput = {
    email: string
    otp: string
  }

  export type OtpCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    otp?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type OtpMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    otp?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type OtpMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    otp?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumStatusKoasFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusKoas | EnumStatusKoasFieldRefInput<$PrismaModel>
    in?: $Enums.StatusKoas[]
    notIn?: $Enums.StatusKoas[]
    not?: NestedEnumStatusKoasFilter<$PrismaModel> | $Enums.StatusKoas
  }

  export type AppointmentListRelationFilter = {
    every?: AppointmentWhereInput
    some?: AppointmentWhereInput
    none?: AppointmentWhereInput
  }

  export type UniversityNullableScalarRelationFilter = {
    is?: UniversityWhereInput | null
    isNot?: UniversityWhereInput | null
  }

  export type AppointmentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type KoasProfileOrderByRelevanceInput = {
    fields: KoasProfileOrderByRelevanceFieldEnum | KoasProfileOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type KoasProfileCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    koasNumber?: SortOrder
    age?: SortOrder
    gender?: SortOrder
    departement?: SortOrder
    university?: SortOrder
    bio?: SortOrder
    whatsappLink?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    universityId?: SortOrder
    experience?: SortOrder
  }

  export type KoasProfileAvgOrderByAggregateInput = {
    experience?: SortOrder
  }

  export type KoasProfileMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    koasNumber?: SortOrder
    age?: SortOrder
    gender?: SortOrder
    departement?: SortOrder
    university?: SortOrder
    bio?: SortOrder
    whatsappLink?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    universityId?: SortOrder
    experience?: SortOrder
  }

  export type KoasProfileMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    koasNumber?: SortOrder
    age?: SortOrder
    gender?: SortOrder
    departement?: SortOrder
    university?: SortOrder
    bio?: SortOrder
    whatsappLink?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    universityId?: SortOrder
    experience?: SortOrder
  }

  export type KoasProfileSumOrderByAggregateInput = {
    experience?: SortOrder
  }

  export type EnumStatusKoasWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusKoas | EnumStatusKoasFieldRefInput<$PrismaModel>
    in?: $Enums.StatusKoas[]
    notIn?: $Enums.StatusKoas[]
    not?: NestedEnumStatusKoasWithAggregatesFilter<$PrismaModel> | $Enums.StatusKoas
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusKoasFilter<$PrismaModel>
    _max?: NestedEnumStatusKoasFilter<$PrismaModel>
  }

  export type PasienProfileOrderByRelevanceInput = {
    fields: PasienProfileOrderByRelevanceFieldEnum | PasienProfileOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type PasienProfileCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    age?: SortOrder
    gender?: SortOrder
    bio?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
  }

  export type PasienProfileMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    age?: SortOrder
    gender?: SortOrder
    bio?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
  }

  export type PasienProfileMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    age?: SortOrder
    gender?: SortOrder
    bio?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
  }

  export type FasilitatorProfileOrderByRelevanceInput = {
    fields: FasilitatorProfileOrderByRelevanceFieldEnum | FasilitatorProfileOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type FasilitatorProfileCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    university?: SortOrder
  }

  export type FasilitatorProfileMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    university?: SortOrder
  }

  export type FasilitatorProfileMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    university?: SortOrder
  }

  export type FloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type KoasProfileListRelationFilter = {
    every?: KoasProfileWhereInput
    some?: KoasProfileWhereInput
    none?: KoasProfileWhereInput
  }

  export type KoasProfileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UniversityOrderByRelevanceInput = {
    fields: UniversityOrderByRelevanceFieldEnum | UniversityOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type UniversityCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    alias?: SortOrder
    location?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    image?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
  }

  export type UniversityAvgOrderByAggregateInput = {
    latitude?: SortOrder
    longitude?: SortOrder
  }

  export type UniversityMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    alias?: SortOrder
    location?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    image?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
  }

  export type UniversityMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    alias?: SortOrder
    location?: SortOrder
    latitude?: SortOrder
    longitude?: SortOrder
    image?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
  }

  export type UniversitySumOrderByAggregateInput = {
    latitude?: SortOrder
    longitude?: SortOrder
  }

  export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }
  export type JsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue
    lte?: InputJsonValue
    gt?: InputJsonValue
    gte?: InputJsonValue
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type EnumStatusPostFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusPost | EnumStatusPostFieldRefInput<$PrismaModel>
    in?: $Enums.StatusPost[]
    notIn?: $Enums.StatusPost[]
    not?: NestedEnumStatusPostFilter<$PrismaModel> | $Enums.StatusPost
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type KoasProfileScalarRelationFilter = {
    is?: KoasProfileWhereInput
    isNot?: KoasProfileWhereInput
  }

  export type TreatmentTypeScalarRelationFilter = {
    is?: TreatmentTypeWhereInput
    isNot?: TreatmentTypeWhereInput
  }

  export type ScheduleListRelationFilter = {
    every?: ScheduleWhereInput
    some?: ScheduleWhereInput
    none?: ScheduleWhereInput
  }

  export type ScheduleOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PostOrderByRelevanceInput = {
    fields: PostOrderByRelevanceFieldEnum | PostOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type PostCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    koasId?: SortOrder
    treatmentId?: SortOrder
    title?: SortOrder
    desc?: SortOrder
    patientRequirement?: SortOrder
    status?: SortOrder
    published?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    requiredParticipant?: SortOrder
    images?: SortOrder
  }

  export type PostAvgOrderByAggregateInput = {
    requiredParticipant?: SortOrder
  }

  export type PostMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    koasId?: SortOrder
    treatmentId?: SortOrder
    title?: SortOrder
    desc?: SortOrder
    status?: SortOrder
    published?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    requiredParticipant?: SortOrder
  }

  export type PostMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    koasId?: SortOrder
    treatmentId?: SortOrder
    title?: SortOrder
    desc?: SortOrder
    status?: SortOrder
    published?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    requiredParticipant?: SortOrder
  }

  export type PostSumOrderByAggregateInput = {
    requiredParticipant?: SortOrder
  }
  export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue
    lte?: InputJsonValue
    gt?: InputJsonValue
    gte?: InputJsonValue
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type EnumStatusPostWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusPost | EnumStatusPostFieldRefInput<$PrismaModel>
    in?: $Enums.StatusPost[]
    notIn?: $Enums.StatusPost[]
    not?: NestedEnumStatusPostWithAggregatesFilter<$PrismaModel> | $Enums.StatusPost
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusPostFilter<$PrismaModel>
    _max?: NestedEnumStatusPostFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type PostScalarRelationFilter = {
    is?: PostWhereInput
    isNot?: PostWhereInput
  }

  export type LikeOrderByRelevanceInput = {
    fields: LikeOrderByRelevanceFieldEnum | LikeOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type LikeCountOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type LikeMaxOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type LikeMinOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    userId?: SortOrder
    createdAt?: SortOrder
  }

  export type EnumStatusNotificationFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusNotification | EnumStatusNotificationFieldRefInput<$PrismaModel>
    in?: $Enums.StatusNotification[]
    notIn?: $Enums.StatusNotification[]
    not?: NestedEnumStatusNotificationFilter<$PrismaModel> | $Enums.StatusNotification
  }

  export type NotificationOrderByRelevanceInput = {
    fields: NotificationOrderByRelevanceFieldEnum | NotificationOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type NotificationCountOrderByAggregateInput = {
    id?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrder
    senderId?: SortOrder
    status?: SortOrder
    title?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type NotificationMaxOrderByAggregateInput = {
    id?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrder
    senderId?: SortOrder
    status?: SortOrder
    title?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type NotificationMinOrderByAggregateInput = {
    id?: SortOrder
    message?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrder
    senderId?: SortOrder
    status?: SortOrder
    title?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type EnumStatusNotificationWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusNotification | EnumStatusNotificationFieldRefInput<$PrismaModel>
    in?: $Enums.StatusNotification[]
    notIn?: $Enums.StatusNotification[]
    not?: NestedEnumStatusNotificationWithAggregatesFilter<$PrismaModel> | $Enums.StatusNotification
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusNotificationFilter<$PrismaModel>
    _max?: NestedEnumStatusNotificationFilter<$PrismaModel>
  }

  export type TreatmentTypeOrderByRelevanceInput = {
    fields: TreatmentTypeOrderByRelevanceFieldEnum | TreatmentTypeOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type TreatmentTypeCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    alias?: SortOrder
    image?: SortOrder
  }

  export type TreatmentTypeMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    alias?: SortOrder
    image?: SortOrder
  }

  export type TreatmentTypeMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    createdAt?: SortOrder
    updateAt?: SortOrder
    alias?: SortOrder
    image?: SortOrder
  }

  export type TimeslotListRelationFilter = {
    every?: TimeslotWhereInput
    some?: TimeslotWhereInput
    none?: TimeslotWhereInput
  }

  export type TimeslotOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ScheduleOrderByRelevanceInput = {
    fields: ScheduleOrderByRelevanceFieldEnum | ScheduleOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type ScheduleCountOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    createdAt?: SortOrder
    dateEnd?: SortOrder
    dateStart?: SortOrder
    updateAt?: SortOrder
  }

  export type ScheduleMaxOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    createdAt?: SortOrder
    dateEnd?: SortOrder
    dateStart?: SortOrder
    updateAt?: SortOrder
  }

  export type ScheduleMinOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    createdAt?: SortOrder
    dateEnd?: SortOrder
    dateStart?: SortOrder
    updateAt?: SortOrder
  }

  export type ScheduleScalarRelationFilter = {
    is?: ScheduleWhereInput
    isNot?: ScheduleWhereInput
  }

  export type TimeslotOrderByRelevanceInput = {
    fields: TimeslotOrderByRelevanceFieldEnum | TimeslotOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type TimeslotUnique_timeslotCompoundUniqueInput = {
    scheduleId: string
    startTime: string
    endTime: string
  }

  export type TimeslotCountOrderByAggregateInput = {
    id?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    maxParticipants?: SortOrder
    currentParticipants?: SortOrder
    isAvailable?: SortOrder
    scheduleId?: SortOrder
  }

  export type TimeslotAvgOrderByAggregateInput = {
    maxParticipants?: SortOrder
    currentParticipants?: SortOrder
  }

  export type TimeslotMaxOrderByAggregateInput = {
    id?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    maxParticipants?: SortOrder
    currentParticipants?: SortOrder
    isAvailable?: SortOrder
    scheduleId?: SortOrder
  }

  export type TimeslotMinOrderByAggregateInput = {
    id?: SortOrder
    startTime?: SortOrder
    endTime?: SortOrder
    maxParticipants?: SortOrder
    currentParticipants?: SortOrder
    isAvailable?: SortOrder
    scheduleId?: SortOrder
  }

  export type TimeslotSumOrderByAggregateInput = {
    maxParticipants?: SortOrder
    currentParticipants?: SortOrder
  }

  export type DecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
  }

  export type ReviewOrderByRelevanceInput = {
    fields: ReviewOrderByRelevanceFieldEnum | ReviewOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type ReviewCountOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    pasienId?: SortOrder
    rating?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrder
  }

  export type ReviewAvgOrderByAggregateInput = {
    rating?: SortOrder
  }

  export type ReviewMaxOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    pasienId?: SortOrder
    rating?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrder
  }

  export type ReviewMinOrderByAggregateInput = {
    id?: SortOrder
    postId?: SortOrder
    pasienId?: SortOrder
    rating?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    koasId?: SortOrder
  }

  export type ReviewSumOrderByAggregateInput = {
    rating?: SortOrder
  }

  export type DecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedDecimalFilter<$PrismaModel>
    _sum?: NestedDecimalFilter<$PrismaModel>
    _min?: NestedDecimalFilter<$PrismaModel>
    _max?: NestedDecimalFilter<$PrismaModel>
  }

  export type EnumStatusAppointmentFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusAppointment | EnumStatusAppointmentFieldRefInput<$PrismaModel>
    in?: $Enums.StatusAppointment[]
    notIn?: $Enums.StatusAppointment[]
    not?: NestedEnumStatusAppointmentFilter<$PrismaModel> | $Enums.StatusAppointment
  }

  export type PasienProfileScalarRelationFilter = {
    is?: PasienProfileWhereInput
    isNot?: PasienProfileWhereInput
  }

  export type TimeslotScalarRelationFilter = {
    is?: TimeslotWhereInput
    isNot?: TimeslotWhereInput
  }

  export type AppointmentOrderByRelevanceInput = {
    fields: AppointmentOrderByRelevanceFieldEnum | AppointmentOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type AppointmentCountOrderByAggregateInput = {
    id?: SortOrder
    pasienId?: SortOrder
    koasId?: SortOrder
    scheduleId?: SortOrder
    timeslotId?: SortOrder
    date?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AppointmentMaxOrderByAggregateInput = {
    id?: SortOrder
    pasienId?: SortOrder
    koasId?: SortOrder
    scheduleId?: SortOrder
    timeslotId?: SortOrder
    date?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type AppointmentMinOrderByAggregateInput = {
    id?: SortOrder
    pasienId?: SortOrder
    koasId?: SortOrder
    scheduleId?: SortOrder
    timeslotId?: SortOrder
    date?: SortOrder
    status?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumStatusAppointmentWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusAppointment | EnumStatusAppointmentFieldRefInput<$PrismaModel>
    in?: $Enums.StatusAppointment[]
    notIn?: $Enums.StatusAppointment[]
    not?: NestedEnumStatusAppointmentWithAggregatesFilter<$PrismaModel> | $Enums.StatusAppointment
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusAppointmentFilter<$PrismaModel>
    _max?: NestedEnumStatusAppointmentFilter<$PrismaModel>
  }

  export type verificationrequestOrderByRelevanceInput = {
    fields: verificationrequestOrderByRelevanceFieldEnum | verificationrequestOrderByRelevanceFieldEnum[]
    sort: SortOrder
    search: string
  }

  export type verificationrequestEmailTokenCompoundUniqueInput = {
    email: string
    token: string
  }

  export type verificationrequestCountOrderByAggregateInput = {
    id?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    email?: SortOrder
  }

  export type verificationrequestMaxOrderByAggregateInput = {
    id?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    email?: SortOrder
  }

  export type verificationrequestMinOrderByAggregateInput = {
    id?: SortOrder
    token?: SortOrder
    expires?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    email?: SortOrder
  }

  export type AccountCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type FasilitatorProfileCreateNestedOneWithoutUserInput = {
    create?: XOR<FasilitatorProfileCreateWithoutUserInput, FasilitatorProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: FasilitatorProfileCreateOrConnectWithoutUserInput
    connect?: FasilitatorProfileWhereUniqueInput
  }

  export type KoasProfileCreateNestedOneWithoutUserInput = {
    create?: XOR<KoasProfileCreateWithoutUserInput, KoasProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUserInput
    connect?: KoasProfileWhereUniqueInput
  }

  export type LikeCreateNestedManyWithoutUserInput = {
    create?: XOR<LikeCreateWithoutUserInput, LikeUncheckedCreateWithoutUserInput> | LikeCreateWithoutUserInput[] | LikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutUserInput | LikeCreateOrConnectWithoutUserInput[]
    createMany?: LikeCreateManyUserInputEnvelope
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
  }

  export type NotificationCreateNestedManyWithoutSenderInput = {
    create?: XOR<NotificationCreateWithoutSenderInput, NotificationUncheckedCreateWithoutSenderInput> | NotificationCreateWithoutSenderInput[] | NotificationUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSenderInput | NotificationCreateOrConnectWithoutSenderInput[]
    createMany?: NotificationCreateManySenderInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type NotificationCreateNestedManyWithoutRecipientInput = {
    create?: XOR<NotificationCreateWithoutRecipientInput, NotificationUncheckedCreateWithoutRecipientInput> | NotificationCreateWithoutRecipientInput[] | NotificationUncheckedCreateWithoutRecipientInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutRecipientInput | NotificationCreateOrConnectWithoutRecipientInput[]
    createMany?: NotificationCreateManyRecipientInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type PasienProfileCreateNestedOneWithoutUserInput = {
    create?: XOR<PasienProfileCreateWithoutUserInput, PasienProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: PasienProfileCreateOrConnectWithoutUserInput
    connect?: PasienProfileWhereUniqueInput
  }

  export type PostCreateNestedManyWithoutUserInput = {
    create?: XOR<PostCreateWithoutUserInput, PostUncheckedCreateWithoutUserInput> | PostCreateWithoutUserInput[] | PostUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PostCreateOrConnectWithoutUserInput | PostCreateOrConnectWithoutUserInput[]
    createMany?: PostCreateManyUserInputEnvelope
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
  }

  export type ReviewCreateNestedManyWithoutUserInput = {
    create?: XOR<ReviewCreateWithoutUserInput, ReviewUncheckedCreateWithoutUserInput> | ReviewCreateWithoutUserInput[] | ReviewUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutUserInput | ReviewCreateOrConnectWithoutUserInput[]
    createMany?: ReviewCreateManyUserInputEnvelope
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
  }

  export type SessionCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type AccountUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<FasilitatorProfileCreateWithoutUserInput, FasilitatorProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: FasilitatorProfileCreateOrConnectWithoutUserInput
    connect?: FasilitatorProfileWhereUniqueInput
  }

  export type KoasProfileUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<KoasProfileCreateWithoutUserInput, KoasProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUserInput
    connect?: KoasProfileWhereUniqueInput
  }

  export type LikeUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<LikeCreateWithoutUserInput, LikeUncheckedCreateWithoutUserInput> | LikeCreateWithoutUserInput[] | LikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutUserInput | LikeCreateOrConnectWithoutUserInput[]
    createMany?: LikeCreateManyUserInputEnvelope
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
  }

  export type NotificationUncheckedCreateNestedManyWithoutSenderInput = {
    create?: XOR<NotificationCreateWithoutSenderInput, NotificationUncheckedCreateWithoutSenderInput> | NotificationCreateWithoutSenderInput[] | NotificationUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSenderInput | NotificationCreateOrConnectWithoutSenderInput[]
    createMany?: NotificationCreateManySenderInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type NotificationUncheckedCreateNestedManyWithoutRecipientInput = {
    create?: XOR<NotificationCreateWithoutRecipientInput, NotificationUncheckedCreateWithoutRecipientInput> | NotificationCreateWithoutRecipientInput[] | NotificationUncheckedCreateWithoutRecipientInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutRecipientInput | NotificationCreateOrConnectWithoutRecipientInput[]
    createMany?: NotificationCreateManyRecipientInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type PasienProfileUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<PasienProfileCreateWithoutUserInput, PasienProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: PasienProfileCreateOrConnectWithoutUserInput
    connect?: PasienProfileWhereUniqueInput
  }

  export type PostUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<PostCreateWithoutUserInput, PostUncheckedCreateWithoutUserInput> | PostCreateWithoutUserInput[] | PostUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PostCreateOrConnectWithoutUserInput | PostCreateOrConnectWithoutUserInput[]
    createMany?: PostCreateManyUserInputEnvelope
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
  }

  export type ReviewUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ReviewCreateWithoutUserInput, ReviewUncheckedCreateWithoutUserInput> | ReviewCreateWithoutUserInput[] | ReviewUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutUserInput | ReviewCreateOrConnectWithoutUserInput[]
    createMany?: ReviewCreateManyUserInputEnvelope
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
  }

  export type SessionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type NullableEnumRoleFieldUpdateOperationsInput = {
    set?: $Enums.Role | null
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type AccountUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type FasilitatorProfileUpdateOneWithoutUserNestedInput = {
    create?: XOR<FasilitatorProfileCreateWithoutUserInput, FasilitatorProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: FasilitatorProfileCreateOrConnectWithoutUserInput
    upsert?: FasilitatorProfileUpsertWithoutUserInput
    disconnect?: FasilitatorProfileWhereInput | boolean
    delete?: FasilitatorProfileWhereInput | boolean
    connect?: FasilitatorProfileWhereUniqueInput
    update?: XOR<XOR<FasilitatorProfileUpdateToOneWithWhereWithoutUserInput, FasilitatorProfileUpdateWithoutUserInput>, FasilitatorProfileUncheckedUpdateWithoutUserInput>
  }

  export type KoasProfileUpdateOneWithoutUserNestedInput = {
    create?: XOR<KoasProfileCreateWithoutUserInput, KoasProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUserInput
    upsert?: KoasProfileUpsertWithoutUserInput
    disconnect?: KoasProfileWhereInput | boolean
    delete?: KoasProfileWhereInput | boolean
    connect?: KoasProfileWhereUniqueInput
    update?: XOR<XOR<KoasProfileUpdateToOneWithWhereWithoutUserInput, KoasProfileUpdateWithoutUserInput>, KoasProfileUncheckedUpdateWithoutUserInput>
  }

  export type LikeUpdateManyWithoutUserNestedInput = {
    create?: XOR<LikeCreateWithoutUserInput, LikeUncheckedCreateWithoutUserInput> | LikeCreateWithoutUserInput[] | LikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutUserInput | LikeCreateOrConnectWithoutUserInput[]
    upsert?: LikeUpsertWithWhereUniqueWithoutUserInput | LikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: LikeCreateManyUserInputEnvelope
    set?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    disconnect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    delete?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    update?: LikeUpdateWithWhereUniqueWithoutUserInput | LikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: LikeUpdateManyWithWhereWithoutUserInput | LikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: LikeScalarWhereInput | LikeScalarWhereInput[]
  }

  export type NotificationUpdateManyWithoutSenderNestedInput = {
    create?: XOR<NotificationCreateWithoutSenderInput, NotificationUncheckedCreateWithoutSenderInput> | NotificationCreateWithoutSenderInput[] | NotificationUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSenderInput | NotificationCreateOrConnectWithoutSenderInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutSenderInput | NotificationUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: NotificationCreateManySenderInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutSenderInput | NotificationUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutSenderInput | NotificationUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type NotificationUpdateManyWithoutRecipientNestedInput = {
    create?: XOR<NotificationCreateWithoutRecipientInput, NotificationUncheckedCreateWithoutRecipientInput> | NotificationCreateWithoutRecipientInput[] | NotificationUncheckedCreateWithoutRecipientInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutRecipientInput | NotificationCreateOrConnectWithoutRecipientInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutRecipientInput | NotificationUpsertWithWhereUniqueWithoutRecipientInput[]
    createMany?: NotificationCreateManyRecipientInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutRecipientInput | NotificationUpdateWithWhereUniqueWithoutRecipientInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutRecipientInput | NotificationUpdateManyWithWhereWithoutRecipientInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type PasienProfileUpdateOneWithoutUserNestedInput = {
    create?: XOR<PasienProfileCreateWithoutUserInput, PasienProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: PasienProfileCreateOrConnectWithoutUserInput
    upsert?: PasienProfileUpsertWithoutUserInput
    disconnect?: PasienProfileWhereInput | boolean
    delete?: PasienProfileWhereInput | boolean
    connect?: PasienProfileWhereUniqueInput
    update?: XOR<XOR<PasienProfileUpdateToOneWithWhereWithoutUserInput, PasienProfileUpdateWithoutUserInput>, PasienProfileUncheckedUpdateWithoutUserInput>
  }

  export type PostUpdateManyWithoutUserNestedInput = {
    create?: XOR<PostCreateWithoutUserInput, PostUncheckedCreateWithoutUserInput> | PostCreateWithoutUserInput[] | PostUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PostCreateOrConnectWithoutUserInput | PostCreateOrConnectWithoutUserInput[]
    upsert?: PostUpsertWithWhereUniqueWithoutUserInput | PostUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PostCreateManyUserInputEnvelope
    set?: PostWhereUniqueInput | PostWhereUniqueInput[]
    disconnect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    delete?: PostWhereUniqueInput | PostWhereUniqueInput[]
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    update?: PostUpdateWithWhereUniqueWithoutUserInput | PostUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PostUpdateManyWithWhereWithoutUserInput | PostUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PostScalarWhereInput | PostScalarWhereInput[]
  }

  export type ReviewUpdateManyWithoutUserNestedInput = {
    create?: XOR<ReviewCreateWithoutUserInput, ReviewUncheckedCreateWithoutUserInput> | ReviewCreateWithoutUserInput[] | ReviewUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutUserInput | ReviewCreateOrConnectWithoutUserInput[]
    upsert?: ReviewUpsertWithWhereUniqueWithoutUserInput | ReviewUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ReviewCreateManyUserInputEnvelope
    set?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    disconnect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    delete?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    update?: ReviewUpdateWithWhereUniqueWithoutUserInput | ReviewUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ReviewUpdateManyWithWhereWithoutUserInput | ReviewUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
  }

  export type SessionUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type AccountUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<FasilitatorProfileCreateWithoutUserInput, FasilitatorProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: FasilitatorProfileCreateOrConnectWithoutUserInput
    upsert?: FasilitatorProfileUpsertWithoutUserInput
    disconnect?: FasilitatorProfileWhereInput | boolean
    delete?: FasilitatorProfileWhereInput | boolean
    connect?: FasilitatorProfileWhereUniqueInput
    update?: XOR<XOR<FasilitatorProfileUpdateToOneWithWhereWithoutUserInput, FasilitatorProfileUpdateWithoutUserInput>, FasilitatorProfileUncheckedUpdateWithoutUserInput>
  }

  export type KoasProfileUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<KoasProfileCreateWithoutUserInput, KoasProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUserInput
    upsert?: KoasProfileUpsertWithoutUserInput
    disconnect?: KoasProfileWhereInput | boolean
    delete?: KoasProfileWhereInput | boolean
    connect?: KoasProfileWhereUniqueInput
    update?: XOR<XOR<KoasProfileUpdateToOneWithWhereWithoutUserInput, KoasProfileUpdateWithoutUserInput>, KoasProfileUncheckedUpdateWithoutUserInput>
  }

  export type LikeUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<LikeCreateWithoutUserInput, LikeUncheckedCreateWithoutUserInput> | LikeCreateWithoutUserInput[] | LikeUncheckedCreateWithoutUserInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutUserInput | LikeCreateOrConnectWithoutUserInput[]
    upsert?: LikeUpsertWithWhereUniqueWithoutUserInput | LikeUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: LikeCreateManyUserInputEnvelope
    set?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    disconnect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    delete?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    update?: LikeUpdateWithWhereUniqueWithoutUserInput | LikeUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: LikeUpdateManyWithWhereWithoutUserInput | LikeUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: LikeScalarWhereInput | LikeScalarWhereInput[]
  }

  export type NotificationUncheckedUpdateManyWithoutSenderNestedInput = {
    create?: XOR<NotificationCreateWithoutSenderInput, NotificationUncheckedCreateWithoutSenderInput> | NotificationCreateWithoutSenderInput[] | NotificationUncheckedCreateWithoutSenderInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSenderInput | NotificationCreateOrConnectWithoutSenderInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutSenderInput | NotificationUpsertWithWhereUniqueWithoutSenderInput[]
    createMany?: NotificationCreateManySenderInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutSenderInput | NotificationUpdateWithWhereUniqueWithoutSenderInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutSenderInput | NotificationUpdateManyWithWhereWithoutSenderInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type NotificationUncheckedUpdateManyWithoutRecipientNestedInput = {
    create?: XOR<NotificationCreateWithoutRecipientInput, NotificationUncheckedCreateWithoutRecipientInput> | NotificationCreateWithoutRecipientInput[] | NotificationUncheckedCreateWithoutRecipientInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutRecipientInput | NotificationCreateOrConnectWithoutRecipientInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutRecipientInput | NotificationUpsertWithWhereUniqueWithoutRecipientInput[]
    createMany?: NotificationCreateManyRecipientInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutRecipientInput | NotificationUpdateWithWhereUniqueWithoutRecipientInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutRecipientInput | NotificationUpdateManyWithWhereWithoutRecipientInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type PasienProfileUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<PasienProfileCreateWithoutUserInput, PasienProfileUncheckedCreateWithoutUserInput>
    connectOrCreate?: PasienProfileCreateOrConnectWithoutUserInput
    upsert?: PasienProfileUpsertWithoutUserInput
    disconnect?: PasienProfileWhereInput | boolean
    delete?: PasienProfileWhereInput | boolean
    connect?: PasienProfileWhereUniqueInput
    update?: XOR<XOR<PasienProfileUpdateToOneWithWhereWithoutUserInput, PasienProfileUpdateWithoutUserInput>, PasienProfileUncheckedUpdateWithoutUserInput>
  }

  export type PostUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<PostCreateWithoutUserInput, PostUncheckedCreateWithoutUserInput> | PostCreateWithoutUserInput[] | PostUncheckedCreateWithoutUserInput[]
    connectOrCreate?: PostCreateOrConnectWithoutUserInput | PostCreateOrConnectWithoutUserInput[]
    upsert?: PostUpsertWithWhereUniqueWithoutUserInput | PostUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: PostCreateManyUserInputEnvelope
    set?: PostWhereUniqueInput | PostWhereUniqueInput[]
    disconnect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    delete?: PostWhereUniqueInput | PostWhereUniqueInput[]
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    update?: PostUpdateWithWhereUniqueWithoutUserInput | PostUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: PostUpdateManyWithWhereWithoutUserInput | PostUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: PostScalarWhereInput | PostScalarWhereInput[]
  }

  export type ReviewUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ReviewCreateWithoutUserInput, ReviewUncheckedCreateWithoutUserInput> | ReviewCreateWithoutUserInput[] | ReviewUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutUserInput | ReviewCreateOrConnectWithoutUserInput[]
    upsert?: ReviewUpsertWithWhereUniqueWithoutUserInput | ReviewUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ReviewCreateManyUserInputEnvelope
    set?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    disconnect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    delete?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    update?: ReviewUpdateWithWhereUniqueWithoutUserInput | ReviewUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ReviewUpdateManyWithWhereWithoutUserInput | ReviewUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
  }

  export type SessionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput> | SessionCreateWithoutUserInput[] | SessionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SessionCreateOrConnectWithoutUserInput | SessionCreateOrConnectWithoutUserInput[]
    upsert?: SessionUpsertWithWhereUniqueWithoutUserInput | SessionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SessionCreateManyUserInputEnvelope
    set?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    disconnect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    delete?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    connect?: SessionWhereUniqueInput | SessionWhereUniqueInput[]
    update?: SessionUpdateWithWhereUniqueWithoutUserInput | SessionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SessionUpdateManyWithWhereWithoutUserInput | SessionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SessionScalarWhereInput | SessionScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutAccountInput = {
    create?: XOR<UserCreateWithoutAccountInput, UserUncheckedCreateWithoutAccountInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountInput
    connect?: UserWhereUniqueInput
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserUpdateOneRequiredWithoutAccountNestedInput = {
    create?: XOR<UserCreateWithoutAccountInput, UserUncheckedCreateWithoutAccountInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountInput
    upsert?: UserUpsertWithoutAccountInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccountInput, UserUpdateWithoutAccountInput>, UserUncheckedUpdateWithoutAccountInput>
  }

  export type UserCreateNestedOneWithoutSessionsInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneWithoutSessionsNestedInput = {
    create?: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSessionsInput
    upsert?: UserUpsertWithoutSessionsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSessionsInput, UserUpdateWithoutSessionsInput>, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type AppointmentCreateNestedManyWithoutKoasInput = {
    create?: XOR<AppointmentCreateWithoutKoasInput, AppointmentUncheckedCreateWithoutKoasInput> | AppointmentCreateWithoutKoasInput[] | AppointmentUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutKoasInput | AppointmentCreateOrConnectWithoutKoasInput[]
    createMany?: AppointmentCreateManyKoasInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type UniversityCreateNestedOneWithoutKoasProfileInput = {
    create?: XOR<UniversityCreateWithoutKoasProfileInput, UniversityUncheckedCreateWithoutKoasProfileInput>
    connectOrCreate?: UniversityCreateOrConnectWithoutKoasProfileInput
    connect?: UniversityWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutKoasProfileInput = {
    create?: XOR<UserCreateWithoutKoasProfileInput, UserUncheckedCreateWithoutKoasProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutKoasProfileInput
    connect?: UserWhereUniqueInput
  }

  export type NotificationCreateNestedManyWithoutKoasProfileInput = {
    create?: XOR<NotificationCreateWithoutKoasProfileInput, NotificationUncheckedCreateWithoutKoasProfileInput> | NotificationCreateWithoutKoasProfileInput[] | NotificationUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutKoasProfileInput | NotificationCreateOrConnectWithoutKoasProfileInput[]
    createMany?: NotificationCreateManyKoasProfileInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type PostCreateNestedManyWithoutKoasInput = {
    create?: XOR<PostCreateWithoutKoasInput, PostUncheckedCreateWithoutKoasInput> | PostCreateWithoutKoasInput[] | PostUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: PostCreateOrConnectWithoutKoasInput | PostCreateOrConnectWithoutKoasInput[]
    createMany?: PostCreateManyKoasInputEnvelope
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
  }

  export type ReviewCreateNestedManyWithoutKoasProfileInput = {
    create?: XOR<ReviewCreateWithoutKoasProfileInput, ReviewUncheckedCreateWithoutKoasProfileInput> | ReviewCreateWithoutKoasProfileInput[] | ReviewUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutKoasProfileInput | ReviewCreateOrConnectWithoutKoasProfileInput[]
    createMany?: ReviewCreateManyKoasProfileInputEnvelope
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
  }

  export type AppointmentUncheckedCreateNestedManyWithoutKoasInput = {
    create?: XOR<AppointmentCreateWithoutKoasInput, AppointmentUncheckedCreateWithoutKoasInput> | AppointmentCreateWithoutKoasInput[] | AppointmentUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutKoasInput | AppointmentCreateOrConnectWithoutKoasInput[]
    createMany?: AppointmentCreateManyKoasInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type NotificationUncheckedCreateNestedManyWithoutKoasProfileInput = {
    create?: XOR<NotificationCreateWithoutKoasProfileInput, NotificationUncheckedCreateWithoutKoasProfileInput> | NotificationCreateWithoutKoasProfileInput[] | NotificationUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutKoasProfileInput | NotificationCreateOrConnectWithoutKoasProfileInput[]
    createMany?: NotificationCreateManyKoasProfileInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type PostUncheckedCreateNestedManyWithoutKoasInput = {
    create?: XOR<PostCreateWithoutKoasInput, PostUncheckedCreateWithoutKoasInput> | PostCreateWithoutKoasInput[] | PostUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: PostCreateOrConnectWithoutKoasInput | PostCreateOrConnectWithoutKoasInput[]
    createMany?: PostCreateManyKoasInputEnvelope
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
  }

  export type ReviewUncheckedCreateNestedManyWithoutKoasProfileInput = {
    create?: XOR<ReviewCreateWithoutKoasProfileInput, ReviewUncheckedCreateWithoutKoasProfileInput> | ReviewCreateWithoutKoasProfileInput[] | ReviewUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutKoasProfileInput | ReviewCreateOrConnectWithoutKoasProfileInput[]
    createMany?: ReviewCreateManyKoasProfileInputEnvelope
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
  }

  export type EnumStatusKoasFieldUpdateOperationsInput = {
    set?: $Enums.StatusKoas
  }

  export type AppointmentUpdateManyWithoutKoasNestedInput = {
    create?: XOR<AppointmentCreateWithoutKoasInput, AppointmentUncheckedCreateWithoutKoasInput> | AppointmentCreateWithoutKoasInput[] | AppointmentUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutKoasInput | AppointmentCreateOrConnectWithoutKoasInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutKoasInput | AppointmentUpsertWithWhereUniqueWithoutKoasInput[]
    createMany?: AppointmentCreateManyKoasInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutKoasInput | AppointmentUpdateWithWhereUniqueWithoutKoasInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutKoasInput | AppointmentUpdateManyWithWhereWithoutKoasInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type UniversityUpdateOneWithoutKoasProfileNestedInput = {
    create?: XOR<UniversityCreateWithoutKoasProfileInput, UniversityUncheckedCreateWithoutKoasProfileInput>
    connectOrCreate?: UniversityCreateOrConnectWithoutKoasProfileInput
    upsert?: UniversityUpsertWithoutKoasProfileInput
    disconnect?: UniversityWhereInput | boolean
    delete?: UniversityWhereInput | boolean
    connect?: UniversityWhereUniqueInput
    update?: XOR<XOR<UniversityUpdateToOneWithWhereWithoutKoasProfileInput, UniversityUpdateWithoutKoasProfileInput>, UniversityUncheckedUpdateWithoutKoasProfileInput>
  }

  export type UserUpdateOneRequiredWithoutKoasProfileNestedInput = {
    create?: XOR<UserCreateWithoutKoasProfileInput, UserUncheckedCreateWithoutKoasProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutKoasProfileInput
    upsert?: UserUpsertWithoutKoasProfileInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutKoasProfileInput, UserUpdateWithoutKoasProfileInput>, UserUncheckedUpdateWithoutKoasProfileInput>
  }

  export type NotificationUpdateManyWithoutKoasProfileNestedInput = {
    create?: XOR<NotificationCreateWithoutKoasProfileInput, NotificationUncheckedCreateWithoutKoasProfileInput> | NotificationCreateWithoutKoasProfileInput[] | NotificationUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutKoasProfileInput | NotificationCreateOrConnectWithoutKoasProfileInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutKoasProfileInput | NotificationUpsertWithWhereUniqueWithoutKoasProfileInput[]
    createMany?: NotificationCreateManyKoasProfileInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutKoasProfileInput | NotificationUpdateWithWhereUniqueWithoutKoasProfileInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutKoasProfileInput | NotificationUpdateManyWithWhereWithoutKoasProfileInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type PostUpdateManyWithoutKoasNestedInput = {
    create?: XOR<PostCreateWithoutKoasInput, PostUncheckedCreateWithoutKoasInput> | PostCreateWithoutKoasInput[] | PostUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: PostCreateOrConnectWithoutKoasInput | PostCreateOrConnectWithoutKoasInput[]
    upsert?: PostUpsertWithWhereUniqueWithoutKoasInput | PostUpsertWithWhereUniqueWithoutKoasInput[]
    createMany?: PostCreateManyKoasInputEnvelope
    set?: PostWhereUniqueInput | PostWhereUniqueInput[]
    disconnect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    delete?: PostWhereUniqueInput | PostWhereUniqueInput[]
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    update?: PostUpdateWithWhereUniqueWithoutKoasInput | PostUpdateWithWhereUniqueWithoutKoasInput[]
    updateMany?: PostUpdateManyWithWhereWithoutKoasInput | PostUpdateManyWithWhereWithoutKoasInput[]
    deleteMany?: PostScalarWhereInput | PostScalarWhereInput[]
  }

  export type ReviewUpdateManyWithoutKoasProfileNestedInput = {
    create?: XOR<ReviewCreateWithoutKoasProfileInput, ReviewUncheckedCreateWithoutKoasProfileInput> | ReviewCreateWithoutKoasProfileInput[] | ReviewUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutKoasProfileInput | ReviewCreateOrConnectWithoutKoasProfileInput[]
    upsert?: ReviewUpsertWithWhereUniqueWithoutKoasProfileInput | ReviewUpsertWithWhereUniqueWithoutKoasProfileInput[]
    createMany?: ReviewCreateManyKoasProfileInputEnvelope
    set?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    disconnect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    delete?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    update?: ReviewUpdateWithWhereUniqueWithoutKoasProfileInput | ReviewUpdateWithWhereUniqueWithoutKoasProfileInput[]
    updateMany?: ReviewUpdateManyWithWhereWithoutKoasProfileInput | ReviewUpdateManyWithWhereWithoutKoasProfileInput[]
    deleteMany?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
  }

  export type AppointmentUncheckedUpdateManyWithoutKoasNestedInput = {
    create?: XOR<AppointmentCreateWithoutKoasInput, AppointmentUncheckedCreateWithoutKoasInput> | AppointmentCreateWithoutKoasInput[] | AppointmentUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutKoasInput | AppointmentCreateOrConnectWithoutKoasInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutKoasInput | AppointmentUpsertWithWhereUniqueWithoutKoasInput[]
    createMany?: AppointmentCreateManyKoasInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutKoasInput | AppointmentUpdateWithWhereUniqueWithoutKoasInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutKoasInput | AppointmentUpdateManyWithWhereWithoutKoasInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput = {
    create?: XOR<NotificationCreateWithoutKoasProfileInput, NotificationUncheckedCreateWithoutKoasProfileInput> | NotificationCreateWithoutKoasProfileInput[] | NotificationUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutKoasProfileInput | NotificationCreateOrConnectWithoutKoasProfileInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutKoasProfileInput | NotificationUpsertWithWhereUniqueWithoutKoasProfileInput[]
    createMany?: NotificationCreateManyKoasProfileInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutKoasProfileInput | NotificationUpdateWithWhereUniqueWithoutKoasProfileInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutKoasProfileInput | NotificationUpdateManyWithWhereWithoutKoasProfileInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type PostUncheckedUpdateManyWithoutKoasNestedInput = {
    create?: XOR<PostCreateWithoutKoasInput, PostUncheckedCreateWithoutKoasInput> | PostCreateWithoutKoasInput[] | PostUncheckedCreateWithoutKoasInput[]
    connectOrCreate?: PostCreateOrConnectWithoutKoasInput | PostCreateOrConnectWithoutKoasInput[]
    upsert?: PostUpsertWithWhereUniqueWithoutKoasInput | PostUpsertWithWhereUniqueWithoutKoasInput[]
    createMany?: PostCreateManyKoasInputEnvelope
    set?: PostWhereUniqueInput | PostWhereUniqueInput[]
    disconnect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    delete?: PostWhereUniqueInput | PostWhereUniqueInput[]
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    update?: PostUpdateWithWhereUniqueWithoutKoasInput | PostUpdateWithWhereUniqueWithoutKoasInput[]
    updateMany?: PostUpdateManyWithWhereWithoutKoasInput | PostUpdateManyWithWhereWithoutKoasInput[]
    deleteMany?: PostScalarWhereInput | PostScalarWhereInput[]
  }

  export type ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput = {
    create?: XOR<ReviewCreateWithoutKoasProfileInput, ReviewUncheckedCreateWithoutKoasProfileInput> | ReviewCreateWithoutKoasProfileInput[] | ReviewUncheckedCreateWithoutKoasProfileInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutKoasProfileInput | ReviewCreateOrConnectWithoutKoasProfileInput[]
    upsert?: ReviewUpsertWithWhereUniqueWithoutKoasProfileInput | ReviewUpsertWithWhereUniqueWithoutKoasProfileInput[]
    createMany?: ReviewCreateManyKoasProfileInputEnvelope
    set?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    disconnect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    delete?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    update?: ReviewUpdateWithWhereUniqueWithoutKoasProfileInput | ReviewUpdateWithWhereUniqueWithoutKoasProfileInput[]
    updateMany?: ReviewUpdateManyWithWhereWithoutKoasProfileInput | ReviewUpdateManyWithWhereWithoutKoasProfileInput[]
    deleteMany?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
  }

  export type AppointmentCreateNestedManyWithoutPasienInput = {
    create?: XOR<AppointmentCreateWithoutPasienInput, AppointmentUncheckedCreateWithoutPasienInput> | AppointmentCreateWithoutPasienInput[] | AppointmentUncheckedCreateWithoutPasienInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPasienInput | AppointmentCreateOrConnectWithoutPasienInput[]
    createMany?: AppointmentCreateManyPasienInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type UserCreateNestedOneWithoutPasienProfileInput = {
    create?: XOR<UserCreateWithoutPasienProfileInput, UserUncheckedCreateWithoutPasienProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutPasienProfileInput
    connect?: UserWhereUniqueInput
  }

  export type AppointmentUncheckedCreateNestedManyWithoutPasienInput = {
    create?: XOR<AppointmentCreateWithoutPasienInput, AppointmentUncheckedCreateWithoutPasienInput> | AppointmentCreateWithoutPasienInput[] | AppointmentUncheckedCreateWithoutPasienInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPasienInput | AppointmentCreateOrConnectWithoutPasienInput[]
    createMany?: AppointmentCreateManyPasienInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AppointmentUpdateManyWithoutPasienNestedInput = {
    create?: XOR<AppointmentCreateWithoutPasienInput, AppointmentUncheckedCreateWithoutPasienInput> | AppointmentCreateWithoutPasienInput[] | AppointmentUncheckedCreateWithoutPasienInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPasienInput | AppointmentCreateOrConnectWithoutPasienInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutPasienInput | AppointmentUpsertWithWhereUniqueWithoutPasienInput[]
    createMany?: AppointmentCreateManyPasienInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutPasienInput | AppointmentUpdateWithWhereUniqueWithoutPasienInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutPasienInput | AppointmentUpdateManyWithWhereWithoutPasienInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type UserUpdateOneRequiredWithoutPasienProfileNestedInput = {
    create?: XOR<UserCreateWithoutPasienProfileInput, UserUncheckedCreateWithoutPasienProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutPasienProfileInput
    upsert?: UserUpsertWithoutPasienProfileInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutPasienProfileInput, UserUpdateWithoutPasienProfileInput>, UserUncheckedUpdateWithoutPasienProfileInput>
  }

  export type AppointmentUncheckedUpdateManyWithoutPasienNestedInput = {
    create?: XOR<AppointmentCreateWithoutPasienInput, AppointmentUncheckedCreateWithoutPasienInput> | AppointmentCreateWithoutPasienInput[] | AppointmentUncheckedCreateWithoutPasienInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutPasienInput | AppointmentCreateOrConnectWithoutPasienInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutPasienInput | AppointmentUpsertWithWhereUniqueWithoutPasienInput[]
    createMany?: AppointmentCreateManyPasienInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutPasienInput | AppointmentUpdateWithWhereUniqueWithoutPasienInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutPasienInput | AppointmentUpdateManyWithWhereWithoutPasienInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutFasilitatorProfileInput = {
    create?: XOR<UserCreateWithoutFasilitatorProfileInput, UserUncheckedCreateWithoutFasilitatorProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutFasilitatorProfileInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutFasilitatorProfileNestedInput = {
    create?: XOR<UserCreateWithoutFasilitatorProfileInput, UserUncheckedCreateWithoutFasilitatorProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutFasilitatorProfileInput
    upsert?: UserUpsertWithoutFasilitatorProfileInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutFasilitatorProfileInput, UserUpdateWithoutFasilitatorProfileInput>, UserUncheckedUpdateWithoutFasilitatorProfileInput>
  }

  export type KoasProfileCreateNestedManyWithoutUniversityInput = {
    create?: XOR<KoasProfileCreateWithoutUniversityInput, KoasProfileUncheckedCreateWithoutUniversityInput> | KoasProfileCreateWithoutUniversityInput[] | KoasProfileUncheckedCreateWithoutUniversityInput[]
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUniversityInput | KoasProfileCreateOrConnectWithoutUniversityInput[]
    createMany?: KoasProfileCreateManyUniversityInputEnvelope
    connect?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
  }

  export type KoasProfileUncheckedCreateNestedManyWithoutUniversityInput = {
    create?: XOR<KoasProfileCreateWithoutUniversityInput, KoasProfileUncheckedCreateWithoutUniversityInput> | KoasProfileCreateWithoutUniversityInput[] | KoasProfileUncheckedCreateWithoutUniversityInput[]
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUniversityInput | KoasProfileCreateOrConnectWithoutUniversityInput[]
    createMany?: KoasProfileCreateManyUniversityInputEnvelope
    connect?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
  }

  export type NullableFloatFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type KoasProfileUpdateManyWithoutUniversityNestedInput = {
    create?: XOR<KoasProfileCreateWithoutUniversityInput, KoasProfileUncheckedCreateWithoutUniversityInput> | KoasProfileCreateWithoutUniversityInput[] | KoasProfileUncheckedCreateWithoutUniversityInput[]
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUniversityInput | KoasProfileCreateOrConnectWithoutUniversityInput[]
    upsert?: KoasProfileUpsertWithWhereUniqueWithoutUniversityInput | KoasProfileUpsertWithWhereUniqueWithoutUniversityInput[]
    createMany?: KoasProfileCreateManyUniversityInputEnvelope
    set?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    disconnect?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    delete?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    connect?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    update?: KoasProfileUpdateWithWhereUniqueWithoutUniversityInput | KoasProfileUpdateWithWhereUniqueWithoutUniversityInput[]
    updateMany?: KoasProfileUpdateManyWithWhereWithoutUniversityInput | KoasProfileUpdateManyWithWhereWithoutUniversityInput[]
    deleteMany?: KoasProfileScalarWhereInput | KoasProfileScalarWhereInput[]
  }

  export type KoasProfileUncheckedUpdateManyWithoutUniversityNestedInput = {
    create?: XOR<KoasProfileCreateWithoutUniversityInput, KoasProfileUncheckedCreateWithoutUniversityInput> | KoasProfileCreateWithoutUniversityInput[] | KoasProfileUncheckedCreateWithoutUniversityInput[]
    connectOrCreate?: KoasProfileCreateOrConnectWithoutUniversityInput | KoasProfileCreateOrConnectWithoutUniversityInput[]
    upsert?: KoasProfileUpsertWithWhereUniqueWithoutUniversityInput | KoasProfileUpsertWithWhereUniqueWithoutUniversityInput[]
    createMany?: KoasProfileCreateManyUniversityInputEnvelope
    set?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    disconnect?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    delete?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    connect?: KoasProfileWhereUniqueInput | KoasProfileWhereUniqueInput[]
    update?: KoasProfileUpdateWithWhereUniqueWithoutUniversityInput | KoasProfileUpdateWithWhereUniqueWithoutUniversityInput[]
    updateMany?: KoasProfileUpdateManyWithWhereWithoutUniversityInput | KoasProfileUpdateManyWithWhereWithoutUniversityInput[]
    deleteMany?: KoasProfileScalarWhereInput | KoasProfileScalarWhereInput[]
  }

  export type LikeCreateNestedManyWithoutPostInput = {
    create?: XOR<LikeCreateWithoutPostInput, LikeUncheckedCreateWithoutPostInput> | LikeCreateWithoutPostInput[] | LikeUncheckedCreateWithoutPostInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutPostInput | LikeCreateOrConnectWithoutPostInput[]
    createMany?: LikeCreateManyPostInputEnvelope
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
  }

  export type KoasProfileCreateNestedOneWithoutPostInput = {
    create?: XOR<KoasProfileCreateWithoutPostInput, KoasProfileUncheckedCreateWithoutPostInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutPostInput
    connect?: KoasProfileWhereUniqueInput
  }

  export type TreatmentTypeCreateNestedOneWithoutPostInput = {
    create?: XOR<TreatmentTypeCreateWithoutPostInput, TreatmentTypeUncheckedCreateWithoutPostInput>
    connectOrCreate?: TreatmentTypeCreateOrConnectWithoutPostInput
    connect?: TreatmentTypeWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutPostInput = {
    create?: XOR<UserCreateWithoutPostInput, UserUncheckedCreateWithoutPostInput>
    connectOrCreate?: UserCreateOrConnectWithoutPostInput
    connect?: UserWhereUniqueInput
  }

  export type ReviewCreateNestedManyWithoutPostInput = {
    create?: XOR<ReviewCreateWithoutPostInput, ReviewUncheckedCreateWithoutPostInput> | ReviewCreateWithoutPostInput[] | ReviewUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutPostInput | ReviewCreateOrConnectWithoutPostInput[]
    createMany?: ReviewCreateManyPostInputEnvelope
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
  }

  export type ScheduleCreateNestedManyWithoutPostInput = {
    create?: XOR<ScheduleCreateWithoutPostInput, ScheduleUncheckedCreateWithoutPostInput> | ScheduleCreateWithoutPostInput[] | ScheduleUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ScheduleCreateOrConnectWithoutPostInput | ScheduleCreateOrConnectWithoutPostInput[]
    createMany?: ScheduleCreateManyPostInputEnvelope
    connect?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
  }

  export type LikeUncheckedCreateNestedManyWithoutPostInput = {
    create?: XOR<LikeCreateWithoutPostInput, LikeUncheckedCreateWithoutPostInput> | LikeCreateWithoutPostInput[] | LikeUncheckedCreateWithoutPostInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutPostInput | LikeCreateOrConnectWithoutPostInput[]
    createMany?: LikeCreateManyPostInputEnvelope
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
  }

  export type ReviewUncheckedCreateNestedManyWithoutPostInput = {
    create?: XOR<ReviewCreateWithoutPostInput, ReviewUncheckedCreateWithoutPostInput> | ReviewCreateWithoutPostInput[] | ReviewUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutPostInput | ReviewCreateOrConnectWithoutPostInput[]
    createMany?: ReviewCreateManyPostInputEnvelope
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
  }

  export type ScheduleUncheckedCreateNestedManyWithoutPostInput = {
    create?: XOR<ScheduleCreateWithoutPostInput, ScheduleUncheckedCreateWithoutPostInput> | ScheduleCreateWithoutPostInput[] | ScheduleUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ScheduleCreateOrConnectWithoutPostInput | ScheduleCreateOrConnectWithoutPostInput[]
    createMany?: ScheduleCreateManyPostInputEnvelope
    connect?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
  }

  export type EnumStatusPostFieldUpdateOperationsInput = {
    set?: $Enums.StatusPost
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type LikeUpdateManyWithoutPostNestedInput = {
    create?: XOR<LikeCreateWithoutPostInput, LikeUncheckedCreateWithoutPostInput> | LikeCreateWithoutPostInput[] | LikeUncheckedCreateWithoutPostInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutPostInput | LikeCreateOrConnectWithoutPostInput[]
    upsert?: LikeUpsertWithWhereUniqueWithoutPostInput | LikeUpsertWithWhereUniqueWithoutPostInput[]
    createMany?: LikeCreateManyPostInputEnvelope
    set?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    disconnect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    delete?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    update?: LikeUpdateWithWhereUniqueWithoutPostInput | LikeUpdateWithWhereUniqueWithoutPostInput[]
    updateMany?: LikeUpdateManyWithWhereWithoutPostInput | LikeUpdateManyWithWhereWithoutPostInput[]
    deleteMany?: LikeScalarWhereInput | LikeScalarWhereInput[]
  }

  export type KoasProfileUpdateOneRequiredWithoutPostNestedInput = {
    create?: XOR<KoasProfileCreateWithoutPostInput, KoasProfileUncheckedCreateWithoutPostInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutPostInput
    upsert?: KoasProfileUpsertWithoutPostInput
    connect?: KoasProfileWhereUniqueInput
    update?: XOR<XOR<KoasProfileUpdateToOneWithWhereWithoutPostInput, KoasProfileUpdateWithoutPostInput>, KoasProfileUncheckedUpdateWithoutPostInput>
  }

  export type TreatmentTypeUpdateOneRequiredWithoutPostNestedInput = {
    create?: XOR<TreatmentTypeCreateWithoutPostInput, TreatmentTypeUncheckedCreateWithoutPostInput>
    connectOrCreate?: TreatmentTypeCreateOrConnectWithoutPostInput
    upsert?: TreatmentTypeUpsertWithoutPostInput
    connect?: TreatmentTypeWhereUniqueInput
    update?: XOR<XOR<TreatmentTypeUpdateToOneWithWhereWithoutPostInput, TreatmentTypeUpdateWithoutPostInput>, TreatmentTypeUncheckedUpdateWithoutPostInput>
  }

  export type UserUpdateOneRequiredWithoutPostNestedInput = {
    create?: XOR<UserCreateWithoutPostInput, UserUncheckedCreateWithoutPostInput>
    connectOrCreate?: UserCreateOrConnectWithoutPostInput
    upsert?: UserUpsertWithoutPostInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutPostInput, UserUpdateWithoutPostInput>, UserUncheckedUpdateWithoutPostInput>
  }

  export type ReviewUpdateManyWithoutPostNestedInput = {
    create?: XOR<ReviewCreateWithoutPostInput, ReviewUncheckedCreateWithoutPostInput> | ReviewCreateWithoutPostInput[] | ReviewUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutPostInput | ReviewCreateOrConnectWithoutPostInput[]
    upsert?: ReviewUpsertWithWhereUniqueWithoutPostInput | ReviewUpsertWithWhereUniqueWithoutPostInput[]
    createMany?: ReviewCreateManyPostInputEnvelope
    set?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    disconnect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    delete?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    update?: ReviewUpdateWithWhereUniqueWithoutPostInput | ReviewUpdateWithWhereUniqueWithoutPostInput[]
    updateMany?: ReviewUpdateManyWithWhereWithoutPostInput | ReviewUpdateManyWithWhereWithoutPostInput[]
    deleteMany?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
  }

  export type ScheduleUpdateManyWithoutPostNestedInput = {
    create?: XOR<ScheduleCreateWithoutPostInput, ScheduleUncheckedCreateWithoutPostInput> | ScheduleCreateWithoutPostInput[] | ScheduleUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ScheduleCreateOrConnectWithoutPostInput | ScheduleCreateOrConnectWithoutPostInput[]
    upsert?: ScheduleUpsertWithWhereUniqueWithoutPostInput | ScheduleUpsertWithWhereUniqueWithoutPostInput[]
    createMany?: ScheduleCreateManyPostInputEnvelope
    set?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    disconnect?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    delete?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    connect?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    update?: ScheduleUpdateWithWhereUniqueWithoutPostInput | ScheduleUpdateWithWhereUniqueWithoutPostInput[]
    updateMany?: ScheduleUpdateManyWithWhereWithoutPostInput | ScheduleUpdateManyWithWhereWithoutPostInput[]
    deleteMany?: ScheduleScalarWhereInput | ScheduleScalarWhereInput[]
  }

  export type LikeUncheckedUpdateManyWithoutPostNestedInput = {
    create?: XOR<LikeCreateWithoutPostInput, LikeUncheckedCreateWithoutPostInput> | LikeCreateWithoutPostInput[] | LikeUncheckedCreateWithoutPostInput[]
    connectOrCreate?: LikeCreateOrConnectWithoutPostInput | LikeCreateOrConnectWithoutPostInput[]
    upsert?: LikeUpsertWithWhereUniqueWithoutPostInput | LikeUpsertWithWhereUniqueWithoutPostInput[]
    createMany?: LikeCreateManyPostInputEnvelope
    set?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    disconnect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    delete?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    connect?: LikeWhereUniqueInput | LikeWhereUniqueInput[]
    update?: LikeUpdateWithWhereUniqueWithoutPostInput | LikeUpdateWithWhereUniqueWithoutPostInput[]
    updateMany?: LikeUpdateManyWithWhereWithoutPostInput | LikeUpdateManyWithWhereWithoutPostInput[]
    deleteMany?: LikeScalarWhereInput | LikeScalarWhereInput[]
  }

  export type ReviewUncheckedUpdateManyWithoutPostNestedInput = {
    create?: XOR<ReviewCreateWithoutPostInput, ReviewUncheckedCreateWithoutPostInput> | ReviewCreateWithoutPostInput[] | ReviewUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ReviewCreateOrConnectWithoutPostInput | ReviewCreateOrConnectWithoutPostInput[]
    upsert?: ReviewUpsertWithWhereUniqueWithoutPostInput | ReviewUpsertWithWhereUniqueWithoutPostInput[]
    createMany?: ReviewCreateManyPostInputEnvelope
    set?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    disconnect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    delete?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    connect?: ReviewWhereUniqueInput | ReviewWhereUniqueInput[]
    update?: ReviewUpdateWithWhereUniqueWithoutPostInput | ReviewUpdateWithWhereUniqueWithoutPostInput[]
    updateMany?: ReviewUpdateManyWithWhereWithoutPostInput | ReviewUpdateManyWithWhereWithoutPostInput[]
    deleteMany?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
  }

  export type ScheduleUncheckedUpdateManyWithoutPostNestedInput = {
    create?: XOR<ScheduleCreateWithoutPostInput, ScheduleUncheckedCreateWithoutPostInput> | ScheduleCreateWithoutPostInput[] | ScheduleUncheckedCreateWithoutPostInput[]
    connectOrCreate?: ScheduleCreateOrConnectWithoutPostInput | ScheduleCreateOrConnectWithoutPostInput[]
    upsert?: ScheduleUpsertWithWhereUniqueWithoutPostInput | ScheduleUpsertWithWhereUniqueWithoutPostInput[]
    createMany?: ScheduleCreateManyPostInputEnvelope
    set?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    disconnect?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    delete?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    connect?: ScheduleWhereUniqueInput | ScheduleWhereUniqueInput[]
    update?: ScheduleUpdateWithWhereUniqueWithoutPostInput | ScheduleUpdateWithWhereUniqueWithoutPostInput[]
    updateMany?: ScheduleUpdateManyWithWhereWithoutPostInput | ScheduleUpdateManyWithWhereWithoutPostInput[]
    deleteMany?: ScheduleScalarWhereInput | ScheduleScalarWhereInput[]
  }

  export type PostCreateNestedOneWithoutLikesInput = {
    create?: XOR<PostCreateWithoutLikesInput, PostUncheckedCreateWithoutLikesInput>
    connectOrCreate?: PostCreateOrConnectWithoutLikesInput
    connect?: PostWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutLikeInput = {
    create?: XOR<UserCreateWithoutLikeInput, UserUncheckedCreateWithoutLikeInput>
    connectOrCreate?: UserCreateOrConnectWithoutLikeInput
    connect?: UserWhereUniqueInput
  }

  export type PostUpdateOneRequiredWithoutLikesNestedInput = {
    create?: XOR<PostCreateWithoutLikesInput, PostUncheckedCreateWithoutLikesInput>
    connectOrCreate?: PostCreateOrConnectWithoutLikesInput
    upsert?: PostUpsertWithoutLikesInput
    connect?: PostWhereUniqueInput
    update?: XOR<XOR<PostUpdateToOneWithWhereWithoutLikesInput, PostUpdateWithoutLikesInput>, PostUncheckedUpdateWithoutLikesInput>
  }

  export type UserUpdateOneRequiredWithoutLikeNestedInput = {
    create?: XOR<UserCreateWithoutLikeInput, UserUncheckedCreateWithoutLikeInput>
    connectOrCreate?: UserCreateOrConnectWithoutLikeInput
    upsert?: UserUpsertWithoutLikeInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutLikeInput, UserUpdateWithoutLikeInput>, UserUncheckedUpdateWithoutLikeInput>
  }

  export type KoasProfileCreateNestedOneWithoutNotificationInput = {
    create?: XOR<KoasProfileCreateWithoutNotificationInput, KoasProfileUncheckedCreateWithoutNotificationInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutNotificationInput
    connect?: KoasProfileWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutSenderInput = {
    create?: XOR<UserCreateWithoutSenderInput, UserUncheckedCreateWithoutSenderInput>
    connectOrCreate?: UserCreateOrConnectWithoutSenderInput
    connect?: UserWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutRecipientInput = {
    create?: XOR<UserCreateWithoutRecipientInput, UserUncheckedCreateWithoutRecipientInput>
    connectOrCreate?: UserCreateOrConnectWithoutRecipientInput
    connect?: UserWhereUniqueInput
  }

  export type EnumStatusNotificationFieldUpdateOperationsInput = {
    set?: $Enums.StatusNotification
  }

  export type KoasProfileUpdateOneWithoutNotificationNestedInput = {
    create?: XOR<KoasProfileCreateWithoutNotificationInput, KoasProfileUncheckedCreateWithoutNotificationInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutNotificationInput
    upsert?: KoasProfileUpsertWithoutNotificationInput
    disconnect?: KoasProfileWhereInput | boolean
    delete?: KoasProfileWhereInput | boolean
    connect?: KoasProfileWhereUniqueInput
    update?: XOR<XOR<KoasProfileUpdateToOneWithWhereWithoutNotificationInput, KoasProfileUpdateWithoutNotificationInput>, KoasProfileUncheckedUpdateWithoutNotificationInput>
  }

  export type UserUpdateOneWithoutSenderNestedInput = {
    create?: XOR<UserCreateWithoutSenderInput, UserUncheckedCreateWithoutSenderInput>
    connectOrCreate?: UserCreateOrConnectWithoutSenderInput
    upsert?: UserUpsertWithoutSenderInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSenderInput, UserUpdateWithoutSenderInput>, UserUncheckedUpdateWithoutSenderInput>
  }

  export type UserUpdateOneWithoutRecipientNestedInput = {
    create?: XOR<UserCreateWithoutRecipientInput, UserUncheckedCreateWithoutRecipientInput>
    connectOrCreate?: UserCreateOrConnectWithoutRecipientInput
    upsert?: UserUpsertWithoutRecipientInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutRecipientInput, UserUpdateWithoutRecipientInput>, UserUncheckedUpdateWithoutRecipientInput>
  }

  export type PostCreateNestedManyWithoutTreatmentInput = {
    create?: XOR<PostCreateWithoutTreatmentInput, PostUncheckedCreateWithoutTreatmentInput> | PostCreateWithoutTreatmentInput[] | PostUncheckedCreateWithoutTreatmentInput[]
    connectOrCreate?: PostCreateOrConnectWithoutTreatmentInput | PostCreateOrConnectWithoutTreatmentInput[]
    createMany?: PostCreateManyTreatmentInputEnvelope
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
  }

  export type PostUncheckedCreateNestedManyWithoutTreatmentInput = {
    create?: XOR<PostCreateWithoutTreatmentInput, PostUncheckedCreateWithoutTreatmentInput> | PostCreateWithoutTreatmentInput[] | PostUncheckedCreateWithoutTreatmentInput[]
    connectOrCreate?: PostCreateOrConnectWithoutTreatmentInput | PostCreateOrConnectWithoutTreatmentInput[]
    createMany?: PostCreateManyTreatmentInputEnvelope
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
  }

  export type PostUpdateManyWithoutTreatmentNestedInput = {
    create?: XOR<PostCreateWithoutTreatmentInput, PostUncheckedCreateWithoutTreatmentInput> | PostCreateWithoutTreatmentInput[] | PostUncheckedCreateWithoutTreatmentInput[]
    connectOrCreate?: PostCreateOrConnectWithoutTreatmentInput | PostCreateOrConnectWithoutTreatmentInput[]
    upsert?: PostUpsertWithWhereUniqueWithoutTreatmentInput | PostUpsertWithWhereUniqueWithoutTreatmentInput[]
    createMany?: PostCreateManyTreatmentInputEnvelope
    set?: PostWhereUniqueInput | PostWhereUniqueInput[]
    disconnect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    delete?: PostWhereUniqueInput | PostWhereUniqueInput[]
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    update?: PostUpdateWithWhereUniqueWithoutTreatmentInput | PostUpdateWithWhereUniqueWithoutTreatmentInput[]
    updateMany?: PostUpdateManyWithWhereWithoutTreatmentInput | PostUpdateManyWithWhereWithoutTreatmentInput[]
    deleteMany?: PostScalarWhereInput | PostScalarWhereInput[]
  }

  export type PostUncheckedUpdateManyWithoutTreatmentNestedInput = {
    create?: XOR<PostCreateWithoutTreatmentInput, PostUncheckedCreateWithoutTreatmentInput> | PostCreateWithoutTreatmentInput[] | PostUncheckedCreateWithoutTreatmentInput[]
    connectOrCreate?: PostCreateOrConnectWithoutTreatmentInput | PostCreateOrConnectWithoutTreatmentInput[]
    upsert?: PostUpsertWithWhereUniqueWithoutTreatmentInput | PostUpsertWithWhereUniqueWithoutTreatmentInput[]
    createMany?: PostCreateManyTreatmentInputEnvelope
    set?: PostWhereUniqueInput | PostWhereUniqueInput[]
    disconnect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    delete?: PostWhereUniqueInput | PostWhereUniqueInput[]
    connect?: PostWhereUniqueInput | PostWhereUniqueInput[]
    update?: PostUpdateWithWhereUniqueWithoutTreatmentInput | PostUpdateWithWhereUniqueWithoutTreatmentInput[]
    updateMany?: PostUpdateManyWithWhereWithoutTreatmentInput | PostUpdateManyWithWhereWithoutTreatmentInput[]
    deleteMany?: PostScalarWhereInput | PostScalarWhereInput[]
  }

  export type AppointmentCreateNestedManyWithoutScheduleInput = {
    create?: XOR<AppointmentCreateWithoutScheduleInput, AppointmentUncheckedCreateWithoutScheduleInput> | AppointmentCreateWithoutScheduleInput[] | AppointmentUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutScheduleInput | AppointmentCreateOrConnectWithoutScheduleInput[]
    createMany?: AppointmentCreateManyScheduleInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type PostCreateNestedOneWithoutScheduleInput = {
    create?: XOR<PostCreateWithoutScheduleInput, PostUncheckedCreateWithoutScheduleInput>
    connectOrCreate?: PostCreateOrConnectWithoutScheduleInput
    connect?: PostWhereUniqueInput
  }

  export type TimeslotCreateNestedManyWithoutScheduleInput = {
    create?: XOR<TimeslotCreateWithoutScheduleInput, TimeslotUncheckedCreateWithoutScheduleInput> | TimeslotCreateWithoutScheduleInput[] | TimeslotUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: TimeslotCreateOrConnectWithoutScheduleInput | TimeslotCreateOrConnectWithoutScheduleInput[]
    createMany?: TimeslotCreateManyScheduleInputEnvelope
    connect?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
  }

  export type AppointmentUncheckedCreateNestedManyWithoutScheduleInput = {
    create?: XOR<AppointmentCreateWithoutScheduleInput, AppointmentUncheckedCreateWithoutScheduleInput> | AppointmentCreateWithoutScheduleInput[] | AppointmentUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutScheduleInput | AppointmentCreateOrConnectWithoutScheduleInput[]
    createMany?: AppointmentCreateManyScheduleInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type TimeslotUncheckedCreateNestedManyWithoutScheduleInput = {
    create?: XOR<TimeslotCreateWithoutScheduleInput, TimeslotUncheckedCreateWithoutScheduleInput> | TimeslotCreateWithoutScheduleInput[] | TimeslotUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: TimeslotCreateOrConnectWithoutScheduleInput | TimeslotCreateOrConnectWithoutScheduleInput[]
    createMany?: TimeslotCreateManyScheduleInputEnvelope
    connect?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
  }

  export type AppointmentUpdateManyWithoutScheduleNestedInput = {
    create?: XOR<AppointmentCreateWithoutScheduleInput, AppointmentUncheckedCreateWithoutScheduleInput> | AppointmentCreateWithoutScheduleInput[] | AppointmentUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutScheduleInput | AppointmentCreateOrConnectWithoutScheduleInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutScheduleInput | AppointmentUpsertWithWhereUniqueWithoutScheduleInput[]
    createMany?: AppointmentCreateManyScheduleInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutScheduleInput | AppointmentUpdateWithWhereUniqueWithoutScheduleInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutScheduleInput | AppointmentUpdateManyWithWhereWithoutScheduleInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type PostUpdateOneRequiredWithoutScheduleNestedInput = {
    create?: XOR<PostCreateWithoutScheduleInput, PostUncheckedCreateWithoutScheduleInput>
    connectOrCreate?: PostCreateOrConnectWithoutScheduleInput
    upsert?: PostUpsertWithoutScheduleInput
    connect?: PostWhereUniqueInput
    update?: XOR<XOR<PostUpdateToOneWithWhereWithoutScheduleInput, PostUpdateWithoutScheduleInput>, PostUncheckedUpdateWithoutScheduleInput>
  }

  export type TimeslotUpdateManyWithoutScheduleNestedInput = {
    create?: XOR<TimeslotCreateWithoutScheduleInput, TimeslotUncheckedCreateWithoutScheduleInput> | TimeslotCreateWithoutScheduleInput[] | TimeslotUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: TimeslotCreateOrConnectWithoutScheduleInput | TimeslotCreateOrConnectWithoutScheduleInput[]
    upsert?: TimeslotUpsertWithWhereUniqueWithoutScheduleInput | TimeslotUpsertWithWhereUniqueWithoutScheduleInput[]
    createMany?: TimeslotCreateManyScheduleInputEnvelope
    set?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    disconnect?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    delete?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    connect?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    update?: TimeslotUpdateWithWhereUniqueWithoutScheduleInput | TimeslotUpdateWithWhereUniqueWithoutScheduleInput[]
    updateMany?: TimeslotUpdateManyWithWhereWithoutScheduleInput | TimeslotUpdateManyWithWhereWithoutScheduleInput[]
    deleteMany?: TimeslotScalarWhereInput | TimeslotScalarWhereInput[]
  }

  export type AppointmentUncheckedUpdateManyWithoutScheduleNestedInput = {
    create?: XOR<AppointmentCreateWithoutScheduleInput, AppointmentUncheckedCreateWithoutScheduleInput> | AppointmentCreateWithoutScheduleInput[] | AppointmentUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutScheduleInput | AppointmentCreateOrConnectWithoutScheduleInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutScheduleInput | AppointmentUpsertWithWhereUniqueWithoutScheduleInput[]
    createMany?: AppointmentCreateManyScheduleInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutScheduleInput | AppointmentUpdateWithWhereUniqueWithoutScheduleInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutScheduleInput | AppointmentUpdateManyWithWhereWithoutScheduleInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type TimeslotUncheckedUpdateManyWithoutScheduleNestedInput = {
    create?: XOR<TimeslotCreateWithoutScheduleInput, TimeslotUncheckedCreateWithoutScheduleInput> | TimeslotCreateWithoutScheduleInput[] | TimeslotUncheckedCreateWithoutScheduleInput[]
    connectOrCreate?: TimeslotCreateOrConnectWithoutScheduleInput | TimeslotCreateOrConnectWithoutScheduleInput[]
    upsert?: TimeslotUpsertWithWhereUniqueWithoutScheduleInput | TimeslotUpsertWithWhereUniqueWithoutScheduleInput[]
    createMany?: TimeslotCreateManyScheduleInputEnvelope
    set?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    disconnect?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    delete?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    connect?: TimeslotWhereUniqueInput | TimeslotWhereUniqueInput[]
    update?: TimeslotUpdateWithWhereUniqueWithoutScheduleInput | TimeslotUpdateWithWhereUniqueWithoutScheduleInput[]
    updateMany?: TimeslotUpdateManyWithWhereWithoutScheduleInput | TimeslotUpdateManyWithWhereWithoutScheduleInput[]
    deleteMany?: TimeslotScalarWhereInput | TimeslotScalarWhereInput[]
  }

  export type AppointmentCreateNestedManyWithoutTimeslotInput = {
    create?: XOR<AppointmentCreateWithoutTimeslotInput, AppointmentUncheckedCreateWithoutTimeslotInput> | AppointmentCreateWithoutTimeslotInput[] | AppointmentUncheckedCreateWithoutTimeslotInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutTimeslotInput | AppointmentCreateOrConnectWithoutTimeslotInput[]
    createMany?: AppointmentCreateManyTimeslotInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type ScheduleCreateNestedOneWithoutTimeslotInput = {
    create?: XOR<ScheduleCreateWithoutTimeslotInput, ScheduleUncheckedCreateWithoutTimeslotInput>
    connectOrCreate?: ScheduleCreateOrConnectWithoutTimeslotInput
    connect?: ScheduleWhereUniqueInput
  }

  export type AppointmentUncheckedCreateNestedManyWithoutTimeslotInput = {
    create?: XOR<AppointmentCreateWithoutTimeslotInput, AppointmentUncheckedCreateWithoutTimeslotInput> | AppointmentCreateWithoutTimeslotInput[] | AppointmentUncheckedCreateWithoutTimeslotInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutTimeslotInput | AppointmentCreateOrConnectWithoutTimeslotInput[]
    createMany?: AppointmentCreateManyTimeslotInputEnvelope
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
  }

  export type AppointmentUpdateManyWithoutTimeslotNestedInput = {
    create?: XOR<AppointmentCreateWithoutTimeslotInput, AppointmentUncheckedCreateWithoutTimeslotInput> | AppointmentCreateWithoutTimeslotInput[] | AppointmentUncheckedCreateWithoutTimeslotInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutTimeslotInput | AppointmentCreateOrConnectWithoutTimeslotInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutTimeslotInput | AppointmentUpsertWithWhereUniqueWithoutTimeslotInput[]
    createMany?: AppointmentCreateManyTimeslotInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutTimeslotInput | AppointmentUpdateWithWhereUniqueWithoutTimeslotInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutTimeslotInput | AppointmentUpdateManyWithWhereWithoutTimeslotInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type ScheduleUpdateOneRequiredWithoutTimeslotNestedInput = {
    create?: XOR<ScheduleCreateWithoutTimeslotInput, ScheduleUncheckedCreateWithoutTimeslotInput>
    connectOrCreate?: ScheduleCreateOrConnectWithoutTimeslotInput
    upsert?: ScheduleUpsertWithoutTimeslotInput
    connect?: ScheduleWhereUniqueInput
    update?: XOR<XOR<ScheduleUpdateToOneWithWhereWithoutTimeslotInput, ScheduleUpdateWithoutTimeslotInput>, ScheduleUncheckedUpdateWithoutTimeslotInput>
  }

  export type AppointmentUncheckedUpdateManyWithoutTimeslotNestedInput = {
    create?: XOR<AppointmentCreateWithoutTimeslotInput, AppointmentUncheckedCreateWithoutTimeslotInput> | AppointmentCreateWithoutTimeslotInput[] | AppointmentUncheckedCreateWithoutTimeslotInput[]
    connectOrCreate?: AppointmentCreateOrConnectWithoutTimeslotInput | AppointmentCreateOrConnectWithoutTimeslotInput[]
    upsert?: AppointmentUpsertWithWhereUniqueWithoutTimeslotInput | AppointmentUpsertWithWhereUniqueWithoutTimeslotInput[]
    createMany?: AppointmentCreateManyTimeslotInputEnvelope
    set?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    disconnect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    delete?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    connect?: AppointmentWhereUniqueInput | AppointmentWhereUniqueInput[]
    update?: AppointmentUpdateWithWhereUniqueWithoutTimeslotInput | AppointmentUpdateWithWhereUniqueWithoutTimeslotInput[]
    updateMany?: AppointmentUpdateManyWithWhereWithoutTimeslotInput | AppointmentUpdateManyWithWhereWithoutTimeslotInput[]
    deleteMany?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
  }

  export type KoasProfileCreateNestedOneWithoutReviewInput = {
    create?: XOR<KoasProfileCreateWithoutReviewInput, KoasProfileUncheckedCreateWithoutReviewInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutReviewInput
    connect?: KoasProfileWhereUniqueInput
  }

  export type PostCreateNestedOneWithoutReviewInput = {
    create?: XOR<PostCreateWithoutReviewInput, PostUncheckedCreateWithoutReviewInput>
    connectOrCreate?: PostCreateOrConnectWithoutReviewInput
    connect?: PostWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutReviewInput = {
    create?: XOR<UserCreateWithoutReviewInput, UserUncheckedCreateWithoutReviewInput>
    connectOrCreate?: UserCreateOrConnectWithoutReviewInput
    connect?: UserWhereUniqueInput
  }

  export type DecimalFieldUpdateOperationsInput = {
    set?: Decimal | DecimalJsLike | number | string
    increment?: Decimal | DecimalJsLike | number | string
    decrement?: Decimal | DecimalJsLike | number | string
    multiply?: Decimal | DecimalJsLike | number | string
    divide?: Decimal | DecimalJsLike | number | string
  }

  export type KoasProfileUpdateOneWithoutReviewNestedInput = {
    create?: XOR<KoasProfileCreateWithoutReviewInput, KoasProfileUncheckedCreateWithoutReviewInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutReviewInput
    upsert?: KoasProfileUpsertWithoutReviewInput
    disconnect?: KoasProfileWhereInput | boolean
    delete?: KoasProfileWhereInput | boolean
    connect?: KoasProfileWhereUniqueInput
    update?: XOR<XOR<KoasProfileUpdateToOneWithWhereWithoutReviewInput, KoasProfileUpdateWithoutReviewInput>, KoasProfileUncheckedUpdateWithoutReviewInput>
  }

  export type PostUpdateOneRequiredWithoutReviewNestedInput = {
    create?: XOR<PostCreateWithoutReviewInput, PostUncheckedCreateWithoutReviewInput>
    connectOrCreate?: PostCreateOrConnectWithoutReviewInput
    upsert?: PostUpsertWithoutReviewInput
    connect?: PostWhereUniqueInput
    update?: XOR<XOR<PostUpdateToOneWithWhereWithoutReviewInput, PostUpdateWithoutReviewInput>, PostUncheckedUpdateWithoutReviewInput>
  }

  export type UserUpdateOneRequiredWithoutReviewNestedInput = {
    create?: XOR<UserCreateWithoutReviewInput, UserUncheckedCreateWithoutReviewInput>
    connectOrCreate?: UserCreateOrConnectWithoutReviewInput
    upsert?: UserUpsertWithoutReviewInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutReviewInput, UserUpdateWithoutReviewInput>, UserUncheckedUpdateWithoutReviewInput>
  }

  export type KoasProfileCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<KoasProfileCreateWithoutAppointmentInput, KoasProfileUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutAppointmentInput
    connect?: KoasProfileWhereUniqueInput
  }

  export type PasienProfileCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<PasienProfileCreateWithoutAppointmentInput, PasienProfileUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: PasienProfileCreateOrConnectWithoutAppointmentInput
    connect?: PasienProfileWhereUniqueInput
  }

  export type ScheduleCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<ScheduleCreateWithoutAppointmentInput, ScheduleUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ScheduleCreateOrConnectWithoutAppointmentInput
    connect?: ScheduleWhereUniqueInput
  }

  export type TimeslotCreateNestedOneWithoutAppointmentInput = {
    create?: XOR<TimeslotCreateWithoutAppointmentInput, TimeslotUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: TimeslotCreateOrConnectWithoutAppointmentInput
    connect?: TimeslotWhereUniqueInput
  }

  export type EnumStatusAppointmentFieldUpdateOperationsInput = {
    set?: $Enums.StatusAppointment
  }

  export type KoasProfileUpdateOneRequiredWithoutAppointmentNestedInput = {
    create?: XOR<KoasProfileCreateWithoutAppointmentInput, KoasProfileUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: KoasProfileCreateOrConnectWithoutAppointmentInput
    upsert?: KoasProfileUpsertWithoutAppointmentInput
    connect?: KoasProfileWhereUniqueInput
    update?: XOR<XOR<KoasProfileUpdateToOneWithWhereWithoutAppointmentInput, KoasProfileUpdateWithoutAppointmentInput>, KoasProfileUncheckedUpdateWithoutAppointmentInput>
  }

  export type PasienProfileUpdateOneRequiredWithoutAppointmentNestedInput = {
    create?: XOR<PasienProfileCreateWithoutAppointmentInput, PasienProfileUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: PasienProfileCreateOrConnectWithoutAppointmentInput
    upsert?: PasienProfileUpsertWithoutAppointmentInput
    connect?: PasienProfileWhereUniqueInput
    update?: XOR<XOR<PasienProfileUpdateToOneWithWhereWithoutAppointmentInput, PasienProfileUpdateWithoutAppointmentInput>, PasienProfileUncheckedUpdateWithoutAppointmentInput>
  }

  export type ScheduleUpdateOneRequiredWithoutAppointmentNestedInput = {
    create?: XOR<ScheduleCreateWithoutAppointmentInput, ScheduleUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: ScheduleCreateOrConnectWithoutAppointmentInput
    upsert?: ScheduleUpsertWithoutAppointmentInput
    connect?: ScheduleWhereUniqueInput
    update?: XOR<XOR<ScheduleUpdateToOneWithWhereWithoutAppointmentInput, ScheduleUpdateWithoutAppointmentInput>, ScheduleUncheckedUpdateWithoutAppointmentInput>
  }

  export type TimeslotUpdateOneRequiredWithoutAppointmentNestedInput = {
    create?: XOR<TimeslotCreateWithoutAppointmentInput, TimeslotUncheckedCreateWithoutAppointmentInput>
    connectOrCreate?: TimeslotCreateOrConnectWithoutAppointmentInput
    upsert?: TimeslotUpsertWithoutAppointmentInput
    connect?: TimeslotWhereUniqueInput
    update?: XOR<XOR<TimeslotUpdateToOneWithWhereWithoutAppointmentInput, TimeslotUpdateWithoutAppointmentInput>, TimeslotUncheckedUpdateWithoutAppointmentInput>
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type NestedEnumRoleNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.Role[] | null
    notIn?: $Enums.Role[] | null
    not?: NestedEnumRoleNullableFilter<$PrismaModel> | $Enums.Role | null
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    search?: string
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type NestedEnumRoleNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel> | null
    in?: $Enums.Role[] | null
    notIn?: $Enums.Role[] | null
    not?: NestedEnumRoleNullableWithAggregatesFilter<$PrismaModel> | $Enums.Role | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumRoleNullableFilter<$PrismaModel>
    _max?: NestedEnumRoleNullableFilter<$PrismaModel>
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedEnumStatusKoasFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusKoas | EnumStatusKoasFieldRefInput<$PrismaModel>
    in?: $Enums.StatusKoas[]
    notIn?: $Enums.StatusKoas[]
    not?: NestedEnumStatusKoasFilter<$PrismaModel> | $Enums.StatusKoas
  }

  export type NestedEnumStatusKoasWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusKoas | EnumStatusKoasFieldRefInput<$PrismaModel>
    in?: $Enums.StatusKoas[]
    notIn?: $Enums.StatusKoas[]
    not?: NestedEnumStatusKoasWithAggregatesFilter<$PrismaModel> | $Enums.StatusKoas
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusKoasFilter<$PrismaModel>
    _max?: NestedEnumStatusKoasFilter<$PrismaModel>
  }

  export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type NestedEnumStatusPostFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusPost | EnumStatusPostFieldRefInput<$PrismaModel>
    in?: $Enums.StatusPost[]
    notIn?: $Enums.StatusPost[]
    not?: NestedEnumStatusPostFilter<$PrismaModel> | $Enums.StatusPost
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }
  export type NestedJsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue
    lte?: InputJsonValue
    gt?: InputJsonValue
    gte?: InputJsonValue
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumStatusPostWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusPost | EnumStatusPostFieldRefInput<$PrismaModel>
    in?: $Enums.StatusPost[]
    notIn?: $Enums.StatusPost[]
    not?: NestedEnumStatusPostWithAggregatesFilter<$PrismaModel> | $Enums.StatusPost
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusPostFilter<$PrismaModel>
    _max?: NestedEnumStatusPostFilter<$PrismaModel>
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedEnumStatusNotificationFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusNotification | EnumStatusNotificationFieldRefInput<$PrismaModel>
    in?: $Enums.StatusNotification[]
    notIn?: $Enums.StatusNotification[]
    not?: NestedEnumStatusNotificationFilter<$PrismaModel> | $Enums.StatusNotification
  }

  export type NestedEnumStatusNotificationWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusNotification | EnumStatusNotificationFieldRefInput<$PrismaModel>
    in?: $Enums.StatusNotification[]
    notIn?: $Enums.StatusNotification[]
    not?: NestedEnumStatusNotificationWithAggregatesFilter<$PrismaModel> | $Enums.StatusNotification
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusNotificationFilter<$PrismaModel>
    _max?: NestedEnumStatusNotificationFilter<$PrismaModel>
  }

  export type NestedDecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
  }

  export type NestedDecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedDecimalFilter<$PrismaModel>
    _sum?: NestedDecimalFilter<$PrismaModel>
    _min?: NestedDecimalFilter<$PrismaModel>
    _max?: NestedDecimalFilter<$PrismaModel>
  }

  export type NestedEnumStatusAppointmentFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusAppointment | EnumStatusAppointmentFieldRefInput<$PrismaModel>
    in?: $Enums.StatusAppointment[]
    notIn?: $Enums.StatusAppointment[]
    not?: NestedEnumStatusAppointmentFilter<$PrismaModel> | $Enums.StatusAppointment
  }

  export type NestedEnumStatusAppointmentWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.StatusAppointment | EnumStatusAppointmentFieldRefInput<$PrismaModel>
    in?: $Enums.StatusAppointment[]
    notIn?: $Enums.StatusAppointment[]
    not?: NestedEnumStatusAppointmentWithAggregatesFilter<$PrismaModel> | $Enums.StatusAppointment
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumStatusAppointmentFilter<$PrismaModel>
    _max?: NestedEnumStatusAppointmentFilter<$PrismaModel>
  }

  export type AccountCreateWithoutUserInput = {
    type?: string | null
    provider: string
    scope?: string | null
    access_token?: string | null
    expires_at?: number | null
    id_token?: string | null
    providerAccountId: string
    refresh_token?: string | null
    token_type?: string | null
    id?: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUncheckedCreateWithoutUserInput = {
    type?: string | null
    provider: string
    scope?: string | null
    access_token?: string | null
    expires_at?: number | null
    id_token?: string | null
    providerAccountId: string
    refresh_token?: string | null
    token_type?: string | null
    id?: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountCreateOrConnectWithoutUserInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountCreateManyUserInputEnvelope = {
    data: AccountCreateManyUserInput | AccountCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type FasilitatorProfileCreateWithoutUserInput = {
    id?: string
    university?: string | null
  }

  export type FasilitatorProfileUncheckedCreateWithoutUserInput = {
    id?: string
    university?: string | null
  }

  export type FasilitatorProfileCreateOrConnectWithoutUserInput = {
    where: FasilitatorProfileWhereUniqueInput
    create: XOR<FasilitatorProfileCreateWithoutUserInput, FasilitatorProfileUncheckedCreateWithoutUserInput>
  }

  export type KoasProfileCreateWithoutUserInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentCreateNestedManyWithoutKoasInput
    University?: UniversityCreateNestedOneWithoutKoasProfileInput
    Notification?: NotificationCreateNestedManyWithoutKoasProfileInput
    Post?: PostCreateNestedManyWithoutKoasInput
    Review?: ReviewCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUncheckedCreateWithoutUserInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutKoasInput
    Notification?: NotificationUncheckedCreateNestedManyWithoutKoasProfileInput
    Post?: PostUncheckedCreateNestedManyWithoutKoasInput
    Review?: ReviewUncheckedCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileCreateOrConnectWithoutUserInput = {
    where: KoasProfileWhereUniqueInput
    create: XOR<KoasProfileCreateWithoutUserInput, KoasProfileUncheckedCreateWithoutUserInput>
  }

  export type LikeCreateWithoutUserInput = {
    id?: string
    createdAt?: Date | string
    Post: PostCreateNestedOneWithoutLikesInput
  }

  export type LikeUncheckedCreateWithoutUserInput = {
    id?: string
    postId: string
    createdAt?: Date | string
  }

  export type LikeCreateOrConnectWithoutUserInput = {
    where: LikeWhereUniqueInput
    create: XOR<LikeCreateWithoutUserInput, LikeUncheckedCreateWithoutUserInput>
  }

  export type LikeCreateManyUserInputEnvelope = {
    data: LikeCreateManyUserInput | LikeCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type NotificationCreateWithoutSenderInput = {
    id?: string
    message: string
    createdAt?: Date | string
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    koasProfile?: KoasProfileCreateNestedOneWithoutNotificationInput
    recipient?: UserCreateNestedOneWithoutRecipientInput
  }

  export type NotificationUncheckedCreateWithoutSenderInput = {
    id?: string
    message: string
    createdAt?: Date | string
    koasId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    userId?: string | null
  }

  export type NotificationCreateOrConnectWithoutSenderInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutSenderInput, NotificationUncheckedCreateWithoutSenderInput>
  }

  export type NotificationCreateManySenderInputEnvelope = {
    data: NotificationCreateManySenderInput | NotificationCreateManySenderInput[]
    skipDuplicates?: boolean
  }

  export type NotificationCreateWithoutRecipientInput = {
    id?: string
    message: string
    createdAt?: Date | string
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    koasProfile?: KoasProfileCreateNestedOneWithoutNotificationInput
    sender?: UserCreateNestedOneWithoutSenderInput
  }

  export type NotificationUncheckedCreateWithoutRecipientInput = {
    id?: string
    message: string
    createdAt?: Date | string
    koasId?: string | null
    senderId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
  }

  export type NotificationCreateOrConnectWithoutRecipientInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutRecipientInput, NotificationUncheckedCreateWithoutRecipientInput>
  }

  export type NotificationCreateManyRecipientInputEnvelope = {
    data: NotificationCreateManyRecipientInput | NotificationCreateManyRecipientInput[]
    skipDuplicates?: boolean
  }

  export type PasienProfileCreateWithoutUserInput = {
    id?: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentCreateNestedManyWithoutPasienInput
  }

  export type PasienProfileUncheckedCreateWithoutUserInput = {
    id?: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutPasienInput
  }

  export type PasienProfileCreateOrConnectWithoutUserInput = {
    where: PasienProfileWhereUniqueInput
    create: XOR<PasienProfileCreateWithoutUserInput, PasienProfileUncheckedCreateWithoutUserInput>
  }

  export type PostCreateWithoutUserInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeCreateNestedManyWithoutPostInput
    koas: KoasProfileCreateNestedOneWithoutPostInput
    treatment: TreatmentTypeCreateNestedOneWithoutPostInput
    Review?: ReviewCreateNestedManyWithoutPostInput
    Schedule?: ScheduleCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateWithoutUserInput = {
    id?: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedCreateNestedManyWithoutPostInput
    Review?: ReviewUncheckedCreateNestedManyWithoutPostInput
    Schedule?: ScheduleUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostCreateOrConnectWithoutUserInput = {
    where: PostWhereUniqueInput
    create: XOR<PostCreateWithoutUserInput, PostUncheckedCreateWithoutUserInput>
  }

  export type PostCreateManyUserInputEnvelope = {
    data: PostCreateManyUserInput | PostCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ReviewCreateWithoutUserInput = {
    id?: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    KoasProfile?: KoasProfileCreateNestedOneWithoutReviewInput
    post: PostCreateNestedOneWithoutReviewInput
  }

  export type ReviewUncheckedCreateWithoutUserInput = {
    id?: string
    postId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    koasId?: string | null
  }

  export type ReviewCreateOrConnectWithoutUserInput = {
    where: ReviewWhereUniqueInput
    create: XOR<ReviewCreateWithoutUserInput, ReviewUncheckedCreateWithoutUserInput>
  }

  export type ReviewCreateManyUserInputEnvelope = {
    data: ReviewCreateManyUserInput | ReviewCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SessionCreateWithoutUserInput = {
    id?: string
    expires: Date | string
    sessionToken: string
    accessToken?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionUncheckedCreateWithoutUserInput = {
    id?: string
    expires: Date | string
    sessionToken: string
    accessToken?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SessionCreateOrConnectWithoutUserInput = {
    where: SessionWhereUniqueInput
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionCreateManyUserInputEnvelope = {
    data: SessionCreateManyUserInput | SessionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AccountUpsertWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    update: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountUpdateWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    data: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
  }

  export type AccountUpdateManyWithWhereWithoutUserInput = {
    where: AccountScalarWhereInput
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutUserInput>
  }

  export type AccountScalarWhereInput = {
    AND?: AccountScalarWhereInput | AccountScalarWhereInput[]
    OR?: AccountScalarWhereInput[]
    NOT?: AccountScalarWhereInput | AccountScalarWhereInput[]
    type?: StringNullableFilter<"Account"> | string | null
    provider?: StringFilter<"Account"> | string
    scope?: StringNullableFilter<"Account"> | string | null
    access_token?: StringNullableFilter<"Account"> | string | null
    expires_at?: IntNullableFilter<"Account"> | number | null
    id_token?: StringNullableFilter<"Account"> | string | null
    providerAccountId?: StringFilter<"Account"> | string
    refresh_token?: StringNullableFilter<"Account"> | string | null
    token_type?: StringNullableFilter<"Account"> | string | null
    userId?: StringFilter<"Account"> | string
    id?: StringFilter<"Account"> | string
    createdAt?: DateTimeFilter<"Account"> | Date | string
    updatedAt?: DateTimeFilter<"Account"> | Date | string
  }

  export type FasilitatorProfileUpsertWithoutUserInput = {
    update: XOR<FasilitatorProfileUpdateWithoutUserInput, FasilitatorProfileUncheckedUpdateWithoutUserInput>
    create: XOR<FasilitatorProfileCreateWithoutUserInput, FasilitatorProfileUncheckedCreateWithoutUserInput>
    where?: FasilitatorProfileWhereInput
  }

  export type FasilitatorProfileUpdateToOneWithWhereWithoutUserInput = {
    where?: FasilitatorProfileWhereInput
    data: XOR<FasilitatorProfileUpdateWithoutUserInput, FasilitatorProfileUncheckedUpdateWithoutUserInput>
  }

  export type FasilitatorProfileUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    university?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type FasilitatorProfileUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    university?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type KoasProfileUpsertWithoutUserInput = {
    update: XOR<KoasProfileUpdateWithoutUserInput, KoasProfileUncheckedUpdateWithoutUserInput>
    create: XOR<KoasProfileCreateWithoutUserInput, KoasProfileUncheckedCreateWithoutUserInput>
    where?: KoasProfileWhereInput
  }

  export type KoasProfileUpdateToOneWithWhereWithoutUserInput = {
    where?: KoasProfileWhereInput
    data: XOR<KoasProfileUpdateWithoutUserInput, KoasProfileUncheckedUpdateWithoutUserInput>
  }

  export type KoasProfileUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUpdateManyWithoutKoasNestedInput
    University?: UniversityUpdateOneWithoutKoasProfileNestedInput
    Notification?: NotificationUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUpdateManyWithoutKoasNestedInput
    Review?: ReviewUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutKoasNestedInput
    Notification?: NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUncheckedUpdateManyWithoutKoasNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput
  }

  export type LikeUpsertWithWhereUniqueWithoutUserInput = {
    where: LikeWhereUniqueInput
    update: XOR<LikeUpdateWithoutUserInput, LikeUncheckedUpdateWithoutUserInput>
    create: XOR<LikeCreateWithoutUserInput, LikeUncheckedCreateWithoutUserInput>
  }

  export type LikeUpdateWithWhereUniqueWithoutUserInput = {
    where: LikeWhereUniqueInput
    data: XOR<LikeUpdateWithoutUserInput, LikeUncheckedUpdateWithoutUserInput>
  }

  export type LikeUpdateManyWithWhereWithoutUserInput = {
    where: LikeScalarWhereInput
    data: XOR<LikeUpdateManyMutationInput, LikeUncheckedUpdateManyWithoutUserInput>
  }

  export type LikeScalarWhereInput = {
    AND?: LikeScalarWhereInput | LikeScalarWhereInput[]
    OR?: LikeScalarWhereInput[]
    NOT?: LikeScalarWhereInput | LikeScalarWhereInput[]
    id?: StringFilter<"Like"> | string
    postId?: StringFilter<"Like"> | string
    userId?: StringFilter<"Like"> | string
    createdAt?: DateTimeFilter<"Like"> | Date | string
  }

  export type NotificationUpsertWithWhereUniqueWithoutSenderInput = {
    where: NotificationWhereUniqueInput
    update: XOR<NotificationUpdateWithoutSenderInput, NotificationUncheckedUpdateWithoutSenderInput>
    create: XOR<NotificationCreateWithoutSenderInput, NotificationUncheckedCreateWithoutSenderInput>
  }

  export type NotificationUpdateWithWhereUniqueWithoutSenderInput = {
    where: NotificationWhereUniqueInput
    data: XOR<NotificationUpdateWithoutSenderInput, NotificationUncheckedUpdateWithoutSenderInput>
  }

  export type NotificationUpdateManyWithWhereWithoutSenderInput = {
    where: NotificationScalarWhereInput
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyWithoutSenderInput>
  }

  export type NotificationScalarWhereInput = {
    AND?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    OR?: NotificationScalarWhereInput[]
    NOT?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    id?: StringFilter<"Notification"> | string
    message?: StringFilter<"Notification"> | string
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    koasId?: StringNullableFilter<"Notification"> | string | null
    senderId?: StringNullableFilter<"Notification"> | string | null
    status?: EnumStatusNotificationFilter<"Notification"> | $Enums.StatusNotification
    title?: StringFilter<"Notification"> | string
    updatedAt?: DateTimeFilter<"Notification"> | Date | string
    userId?: StringNullableFilter<"Notification"> | string | null
  }

  export type NotificationUpsertWithWhereUniqueWithoutRecipientInput = {
    where: NotificationWhereUniqueInput
    update: XOR<NotificationUpdateWithoutRecipientInput, NotificationUncheckedUpdateWithoutRecipientInput>
    create: XOR<NotificationCreateWithoutRecipientInput, NotificationUncheckedCreateWithoutRecipientInput>
  }

  export type NotificationUpdateWithWhereUniqueWithoutRecipientInput = {
    where: NotificationWhereUniqueInput
    data: XOR<NotificationUpdateWithoutRecipientInput, NotificationUncheckedUpdateWithoutRecipientInput>
  }

  export type NotificationUpdateManyWithWhereWithoutRecipientInput = {
    where: NotificationScalarWhereInput
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyWithoutRecipientInput>
  }

  export type PasienProfileUpsertWithoutUserInput = {
    update: XOR<PasienProfileUpdateWithoutUserInput, PasienProfileUncheckedUpdateWithoutUserInput>
    create: XOR<PasienProfileCreateWithoutUserInput, PasienProfileUncheckedCreateWithoutUserInput>
    where?: PasienProfileWhereInput
  }

  export type PasienProfileUpdateToOneWithWhereWithoutUserInput = {
    where?: PasienProfileWhereInput
    data: XOR<PasienProfileUpdateWithoutUserInput, PasienProfileUncheckedUpdateWithoutUserInput>
  }

  export type PasienProfileUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUpdateManyWithoutPasienNestedInput
  }

  export type PasienProfileUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUncheckedUpdateManyWithoutPasienNestedInput
  }

  export type PostUpsertWithWhereUniqueWithoutUserInput = {
    where: PostWhereUniqueInput
    update: XOR<PostUpdateWithoutUserInput, PostUncheckedUpdateWithoutUserInput>
    create: XOR<PostCreateWithoutUserInput, PostUncheckedCreateWithoutUserInput>
  }

  export type PostUpdateWithWhereUniqueWithoutUserInput = {
    where: PostWhereUniqueInput
    data: XOR<PostUpdateWithoutUserInput, PostUncheckedUpdateWithoutUserInput>
  }

  export type PostUpdateManyWithWhereWithoutUserInput = {
    where: PostScalarWhereInput
    data: XOR<PostUpdateManyMutationInput, PostUncheckedUpdateManyWithoutUserInput>
  }

  export type PostScalarWhereInput = {
    AND?: PostScalarWhereInput | PostScalarWhereInput[]
    OR?: PostScalarWhereInput[]
    NOT?: PostScalarWhereInput | PostScalarWhereInput[]
    id?: StringFilter<"Post"> | string
    userId?: StringFilter<"Post"> | string
    koasId?: StringFilter<"Post"> | string
    treatmentId?: StringFilter<"Post"> | string
    title?: StringFilter<"Post"> | string
    desc?: StringFilter<"Post"> | string
    patientRequirement?: JsonNullableFilter<"Post">
    status?: EnumStatusPostFilter<"Post"> | $Enums.StatusPost
    published?: BoolFilter<"Post"> | boolean
    createdAt?: DateTimeFilter<"Post"> | Date | string
    updateAt?: DateTimeFilter<"Post"> | Date | string
    requiredParticipant?: IntFilter<"Post"> | number
    images?: JsonNullableFilter<"Post">
  }

  export type ReviewUpsertWithWhereUniqueWithoutUserInput = {
    where: ReviewWhereUniqueInput
    update: XOR<ReviewUpdateWithoutUserInput, ReviewUncheckedUpdateWithoutUserInput>
    create: XOR<ReviewCreateWithoutUserInput, ReviewUncheckedCreateWithoutUserInput>
  }

  export type ReviewUpdateWithWhereUniqueWithoutUserInput = {
    where: ReviewWhereUniqueInput
    data: XOR<ReviewUpdateWithoutUserInput, ReviewUncheckedUpdateWithoutUserInput>
  }

  export type ReviewUpdateManyWithWhereWithoutUserInput = {
    where: ReviewScalarWhereInput
    data: XOR<ReviewUpdateManyMutationInput, ReviewUncheckedUpdateManyWithoutUserInput>
  }

  export type ReviewScalarWhereInput = {
    AND?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
    OR?: ReviewScalarWhereInput[]
    NOT?: ReviewScalarWhereInput | ReviewScalarWhereInput[]
    id?: StringFilter<"Review"> | string
    postId?: StringFilter<"Review"> | string
    pasienId?: StringFilter<"Review"> | string
    rating?: DecimalFilter<"Review"> | Decimal | DecimalJsLike | number | string
    comment?: StringNullableFilter<"Review"> | string | null
    createdAt?: DateTimeFilter<"Review"> | Date | string
    koasId?: StringNullableFilter<"Review"> | string | null
  }

  export type SessionUpsertWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    update: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
    create: XOR<SessionCreateWithoutUserInput, SessionUncheckedCreateWithoutUserInput>
  }

  export type SessionUpdateWithWhereUniqueWithoutUserInput = {
    where: SessionWhereUniqueInput
    data: XOR<SessionUpdateWithoutUserInput, SessionUncheckedUpdateWithoutUserInput>
  }

  export type SessionUpdateManyWithWhereWithoutUserInput = {
    where: SessionScalarWhereInput
    data: XOR<SessionUpdateManyMutationInput, SessionUncheckedUpdateManyWithoutUserInput>
  }

  export type SessionScalarWhereInput = {
    AND?: SessionScalarWhereInput | SessionScalarWhereInput[]
    OR?: SessionScalarWhereInput[]
    NOT?: SessionScalarWhereInput | SessionScalarWhereInput[]
    id?: StringFilter<"Session"> | string
    expires?: DateTimeFilter<"Session"> | Date | string
    sessionToken?: StringFilter<"Session"> | string
    userId?: StringNullableFilter<"Session"> | string | null
    accessToken?: StringNullableFilter<"Session"> | string | null
    createdAt?: DateTimeFilter<"Session"> | Date | string
    updatedAt?: DateTimeFilter<"Session"> | Date | string
  }

  export type UserCreateWithoutAccountInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAccountInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAccountInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAccountInput, UserUncheckedCreateWithoutAccountInput>
  }

  export type UserUpsertWithoutAccountInput = {
    update: XOR<UserUpdateWithoutAccountInput, UserUncheckedUpdateWithoutAccountInput>
    create: XOR<UserCreateWithoutAccountInput, UserUncheckedCreateWithoutAccountInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAccountInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAccountInput, UserUncheckedUpdateWithoutAccountInput>
  }

  export type UserUpdateWithoutAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAccountInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutSessionsInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSessionsInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSessionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
  }

  export type UserUpsertWithoutSessionsInput = {
    update: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
    create: XOR<UserCreateWithoutSessionsInput, UserUncheckedCreateWithoutSessionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSessionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSessionsInput, UserUncheckedUpdateWithoutSessionsInput>
  }

  export type UserUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AppointmentCreateWithoutKoasInput = {
    id?: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
    pasien: PasienProfileCreateNestedOneWithoutAppointmentInput
    schedule: ScheduleCreateNestedOneWithoutAppointmentInput
    timeslot: TimeslotCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutKoasInput = {
    id?: string
    pasienId: string
    scheduleId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentCreateOrConnectWithoutKoasInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutKoasInput, AppointmentUncheckedCreateWithoutKoasInput>
  }

  export type AppointmentCreateManyKoasInputEnvelope = {
    data: AppointmentCreateManyKoasInput | AppointmentCreateManyKoasInput[]
    skipDuplicates?: boolean
  }

  export type UniversityCreateWithoutKoasProfileInput = {
    id?: string
    name: string
    alias: string
    location: string
    latitude?: number | null
    longitude?: number | null
    image?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
  }

  export type UniversityUncheckedCreateWithoutKoasProfileInput = {
    id?: string
    name: string
    alias: string
    location: string
    latitude?: number | null
    longitude?: number | null
    image?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
  }

  export type UniversityCreateOrConnectWithoutKoasProfileInput = {
    where: UniversityWhereUniqueInput
    create: XOR<UniversityCreateWithoutKoasProfileInput, UniversityUncheckedCreateWithoutKoasProfileInput>
  }

  export type UserCreateWithoutKoasProfileInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutKoasProfileInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutKoasProfileInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutKoasProfileInput, UserUncheckedCreateWithoutKoasProfileInput>
  }

  export type NotificationCreateWithoutKoasProfileInput = {
    id?: string
    message: string
    createdAt?: Date | string
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    sender?: UserCreateNestedOneWithoutSenderInput
    recipient?: UserCreateNestedOneWithoutRecipientInput
  }

  export type NotificationUncheckedCreateWithoutKoasProfileInput = {
    id?: string
    message: string
    createdAt?: Date | string
    senderId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    userId?: string | null
  }

  export type NotificationCreateOrConnectWithoutKoasProfileInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutKoasProfileInput, NotificationUncheckedCreateWithoutKoasProfileInput>
  }

  export type NotificationCreateManyKoasProfileInputEnvelope = {
    data: NotificationCreateManyKoasProfileInput | NotificationCreateManyKoasProfileInput[]
    skipDuplicates?: boolean
  }

  export type PostCreateWithoutKoasInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeCreateNestedManyWithoutPostInput
    treatment: TreatmentTypeCreateNestedOneWithoutPostInput
    user: UserCreateNestedOneWithoutPostInput
    Review?: ReviewCreateNestedManyWithoutPostInput
    Schedule?: ScheduleCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateWithoutKoasInput = {
    id?: string
    userId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedCreateNestedManyWithoutPostInput
    Review?: ReviewUncheckedCreateNestedManyWithoutPostInput
    Schedule?: ScheduleUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostCreateOrConnectWithoutKoasInput = {
    where: PostWhereUniqueInput
    create: XOR<PostCreateWithoutKoasInput, PostUncheckedCreateWithoutKoasInput>
  }

  export type PostCreateManyKoasInputEnvelope = {
    data: PostCreateManyKoasInput | PostCreateManyKoasInput[]
    skipDuplicates?: boolean
  }

  export type ReviewCreateWithoutKoasProfileInput = {
    id?: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    post: PostCreateNestedOneWithoutReviewInput
    user: UserCreateNestedOneWithoutReviewInput
  }

  export type ReviewUncheckedCreateWithoutKoasProfileInput = {
    id?: string
    postId: string
    pasienId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
  }

  export type ReviewCreateOrConnectWithoutKoasProfileInput = {
    where: ReviewWhereUniqueInput
    create: XOR<ReviewCreateWithoutKoasProfileInput, ReviewUncheckedCreateWithoutKoasProfileInput>
  }

  export type ReviewCreateManyKoasProfileInputEnvelope = {
    data: ReviewCreateManyKoasProfileInput | ReviewCreateManyKoasProfileInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentUpsertWithWhereUniqueWithoutKoasInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutKoasInput, AppointmentUncheckedUpdateWithoutKoasInput>
    create: XOR<AppointmentCreateWithoutKoasInput, AppointmentUncheckedCreateWithoutKoasInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutKoasInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutKoasInput, AppointmentUncheckedUpdateWithoutKoasInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutKoasInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutKoasInput>
  }

  export type AppointmentScalarWhereInput = {
    AND?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
    OR?: AppointmentScalarWhereInput[]
    NOT?: AppointmentScalarWhereInput | AppointmentScalarWhereInput[]
    id?: StringFilter<"Appointment"> | string
    pasienId?: StringFilter<"Appointment"> | string
    koasId?: StringFilter<"Appointment"> | string
    scheduleId?: StringFilter<"Appointment"> | string
    timeslotId?: StringFilter<"Appointment"> | string
    date?: StringFilter<"Appointment"> | string
    status?: EnumStatusAppointmentFilter<"Appointment"> | $Enums.StatusAppointment
    createdAt?: DateTimeFilter<"Appointment"> | Date | string
    updatedAt?: DateTimeFilter<"Appointment"> | Date | string
  }

  export type UniversityUpsertWithoutKoasProfileInput = {
    update: XOR<UniversityUpdateWithoutKoasProfileInput, UniversityUncheckedUpdateWithoutKoasProfileInput>
    create: XOR<UniversityCreateWithoutKoasProfileInput, UniversityUncheckedCreateWithoutKoasProfileInput>
    where?: UniversityWhereInput
  }

  export type UniversityUpdateToOneWithWhereWithoutKoasProfileInput = {
    where?: UniversityWhereInput
    data: XOR<UniversityUpdateWithoutKoasProfileInput, UniversityUncheckedUpdateWithoutKoasProfileInput>
  }

  export type UniversityUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    alias?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    latitude?: NullableFloatFieldUpdateOperationsInput | number | null
    longitude?: NullableFloatFieldUpdateOperationsInput | number | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UniversityUncheckedUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    alias?: StringFieldUpdateOperationsInput | string
    location?: StringFieldUpdateOperationsInput | string
    latitude?: NullableFloatFieldUpdateOperationsInput | number | null
    longitude?: NullableFloatFieldUpdateOperationsInput | number | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUpsertWithoutKoasProfileInput = {
    update: XOR<UserUpdateWithoutKoasProfileInput, UserUncheckedUpdateWithoutKoasProfileInput>
    create: XOR<UserCreateWithoutKoasProfileInput, UserUncheckedCreateWithoutKoasProfileInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutKoasProfileInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutKoasProfileInput, UserUncheckedUpdateWithoutKoasProfileInput>
  }

  export type UserUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type NotificationUpsertWithWhereUniqueWithoutKoasProfileInput = {
    where: NotificationWhereUniqueInput
    update: XOR<NotificationUpdateWithoutKoasProfileInput, NotificationUncheckedUpdateWithoutKoasProfileInput>
    create: XOR<NotificationCreateWithoutKoasProfileInput, NotificationUncheckedCreateWithoutKoasProfileInput>
  }

  export type NotificationUpdateWithWhereUniqueWithoutKoasProfileInput = {
    where: NotificationWhereUniqueInput
    data: XOR<NotificationUpdateWithoutKoasProfileInput, NotificationUncheckedUpdateWithoutKoasProfileInput>
  }

  export type NotificationUpdateManyWithWhereWithoutKoasProfileInput = {
    where: NotificationScalarWhereInput
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyWithoutKoasProfileInput>
  }

  export type PostUpsertWithWhereUniqueWithoutKoasInput = {
    where: PostWhereUniqueInput
    update: XOR<PostUpdateWithoutKoasInput, PostUncheckedUpdateWithoutKoasInput>
    create: XOR<PostCreateWithoutKoasInput, PostUncheckedCreateWithoutKoasInput>
  }

  export type PostUpdateWithWhereUniqueWithoutKoasInput = {
    where: PostWhereUniqueInput
    data: XOR<PostUpdateWithoutKoasInput, PostUncheckedUpdateWithoutKoasInput>
  }

  export type PostUpdateManyWithWhereWithoutKoasInput = {
    where: PostScalarWhereInput
    data: XOR<PostUpdateManyMutationInput, PostUncheckedUpdateManyWithoutKoasInput>
  }

  export type ReviewUpsertWithWhereUniqueWithoutKoasProfileInput = {
    where: ReviewWhereUniqueInput
    update: XOR<ReviewUpdateWithoutKoasProfileInput, ReviewUncheckedUpdateWithoutKoasProfileInput>
    create: XOR<ReviewCreateWithoutKoasProfileInput, ReviewUncheckedCreateWithoutKoasProfileInput>
  }

  export type ReviewUpdateWithWhereUniqueWithoutKoasProfileInput = {
    where: ReviewWhereUniqueInput
    data: XOR<ReviewUpdateWithoutKoasProfileInput, ReviewUncheckedUpdateWithoutKoasProfileInput>
  }

  export type ReviewUpdateManyWithWhereWithoutKoasProfileInput = {
    where: ReviewScalarWhereInput
    data: XOR<ReviewUpdateManyMutationInput, ReviewUncheckedUpdateManyWithoutKoasProfileInput>
  }

  export type AppointmentCreateWithoutPasienInput = {
    id?: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
    koas: KoasProfileCreateNestedOneWithoutAppointmentInput
    schedule: ScheduleCreateNestedOneWithoutAppointmentInput
    timeslot: TimeslotCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutPasienInput = {
    id?: string
    koasId: string
    scheduleId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentCreateOrConnectWithoutPasienInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutPasienInput, AppointmentUncheckedCreateWithoutPasienInput>
  }

  export type AppointmentCreateManyPasienInputEnvelope = {
    data: AppointmentCreateManyPasienInput | AppointmentCreateManyPasienInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutPasienProfileInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPasienProfileInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPasienProfileInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPasienProfileInput, UserUncheckedCreateWithoutPasienProfileInput>
  }

  export type AppointmentUpsertWithWhereUniqueWithoutPasienInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutPasienInput, AppointmentUncheckedUpdateWithoutPasienInput>
    create: XOR<AppointmentCreateWithoutPasienInput, AppointmentUncheckedCreateWithoutPasienInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutPasienInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutPasienInput, AppointmentUncheckedUpdateWithoutPasienInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutPasienInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutPasienInput>
  }

  export type UserUpsertWithoutPasienProfileInput = {
    update: XOR<UserUpdateWithoutPasienProfileInput, UserUncheckedUpdateWithoutPasienProfileInput>
    create: XOR<UserCreateWithoutPasienProfileInput, UserUncheckedCreateWithoutPasienProfileInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutPasienProfileInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutPasienProfileInput, UserUncheckedUpdateWithoutPasienProfileInput>
  }

  export type UserUpdateWithoutPasienProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPasienProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutFasilitatorProfileInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutFasilitatorProfileInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutFasilitatorProfileInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutFasilitatorProfileInput, UserUncheckedCreateWithoutFasilitatorProfileInput>
  }

  export type UserUpsertWithoutFasilitatorProfileInput = {
    update: XOR<UserUpdateWithoutFasilitatorProfileInput, UserUncheckedUpdateWithoutFasilitatorProfileInput>
    create: XOR<UserCreateWithoutFasilitatorProfileInput, UserUncheckedCreateWithoutFasilitatorProfileInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutFasilitatorProfileInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutFasilitatorProfileInput, UserUncheckedUpdateWithoutFasilitatorProfileInput>
  }

  export type UserUpdateWithoutFasilitatorProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutFasilitatorProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type KoasProfileCreateWithoutUniversityInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentCreateNestedManyWithoutKoasInput
    user: UserCreateNestedOneWithoutKoasProfileInput
    Notification?: NotificationCreateNestedManyWithoutKoasProfileInput
    Post?: PostCreateNestedManyWithoutKoasInput
    Review?: ReviewCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUncheckedCreateWithoutUniversityInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutKoasInput
    Notification?: NotificationUncheckedCreateNestedManyWithoutKoasProfileInput
    Post?: PostUncheckedCreateNestedManyWithoutKoasInput
    Review?: ReviewUncheckedCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileCreateOrConnectWithoutUniversityInput = {
    where: KoasProfileWhereUniqueInput
    create: XOR<KoasProfileCreateWithoutUniversityInput, KoasProfileUncheckedCreateWithoutUniversityInput>
  }

  export type KoasProfileCreateManyUniversityInputEnvelope = {
    data: KoasProfileCreateManyUniversityInput | KoasProfileCreateManyUniversityInput[]
    skipDuplicates?: boolean
  }

  export type KoasProfileUpsertWithWhereUniqueWithoutUniversityInput = {
    where: KoasProfileWhereUniqueInput
    update: XOR<KoasProfileUpdateWithoutUniversityInput, KoasProfileUncheckedUpdateWithoutUniversityInput>
    create: XOR<KoasProfileCreateWithoutUniversityInput, KoasProfileUncheckedCreateWithoutUniversityInput>
  }

  export type KoasProfileUpdateWithWhereUniqueWithoutUniversityInput = {
    where: KoasProfileWhereUniqueInput
    data: XOR<KoasProfileUpdateWithoutUniversityInput, KoasProfileUncheckedUpdateWithoutUniversityInput>
  }

  export type KoasProfileUpdateManyWithWhereWithoutUniversityInput = {
    where: KoasProfileScalarWhereInput
    data: XOR<KoasProfileUpdateManyMutationInput, KoasProfileUncheckedUpdateManyWithoutUniversityInput>
  }

  export type KoasProfileScalarWhereInput = {
    AND?: KoasProfileScalarWhereInput | KoasProfileScalarWhereInput[]
    OR?: KoasProfileScalarWhereInput[]
    NOT?: KoasProfileScalarWhereInput | KoasProfileScalarWhereInput[]
    id?: StringFilter<"KoasProfile"> | string
    userId?: StringFilter<"KoasProfile"> | string
    koasNumber?: StringNullableFilter<"KoasProfile"> | string | null
    age?: StringNullableFilter<"KoasProfile"> | string | null
    gender?: StringNullableFilter<"KoasProfile"> | string | null
    departement?: StringNullableFilter<"KoasProfile"> | string | null
    university?: StringNullableFilter<"KoasProfile"> | string | null
    bio?: StringNullableFilter<"KoasProfile"> | string | null
    whatsappLink?: StringNullableFilter<"KoasProfile"> | string | null
    status?: EnumStatusKoasFilter<"KoasProfile"> | $Enums.StatusKoas
    createdAt?: DateTimeFilter<"KoasProfile"> | Date | string
    updateAt?: DateTimeFilter<"KoasProfile"> | Date | string
    universityId?: StringNullableFilter<"KoasProfile"> | string | null
    experience?: IntNullableFilter<"KoasProfile"> | number | null
  }

  export type LikeCreateWithoutPostInput = {
    id?: string
    createdAt?: Date | string
    user: UserCreateNestedOneWithoutLikeInput
  }

  export type LikeUncheckedCreateWithoutPostInput = {
    id?: string
    userId: string
    createdAt?: Date | string
  }

  export type LikeCreateOrConnectWithoutPostInput = {
    where: LikeWhereUniqueInput
    create: XOR<LikeCreateWithoutPostInput, LikeUncheckedCreateWithoutPostInput>
  }

  export type LikeCreateManyPostInputEnvelope = {
    data: LikeCreateManyPostInput | LikeCreateManyPostInput[]
    skipDuplicates?: boolean
  }

  export type KoasProfileCreateWithoutPostInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentCreateNestedManyWithoutKoasInput
    University?: UniversityCreateNestedOneWithoutKoasProfileInput
    user: UserCreateNestedOneWithoutKoasProfileInput
    Notification?: NotificationCreateNestedManyWithoutKoasProfileInput
    Review?: ReviewCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUncheckedCreateWithoutPostInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutKoasInput
    Notification?: NotificationUncheckedCreateNestedManyWithoutKoasProfileInput
    Review?: ReviewUncheckedCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileCreateOrConnectWithoutPostInput = {
    where: KoasProfileWhereUniqueInput
    create: XOR<KoasProfileCreateWithoutPostInput, KoasProfileUncheckedCreateWithoutPostInput>
  }

  export type TreatmentTypeCreateWithoutPostInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updateAt?: Date | string
    alias: string
    image?: string | null
  }

  export type TreatmentTypeUncheckedCreateWithoutPostInput = {
    id?: string
    name: string
    createdAt?: Date | string
    updateAt?: Date | string
    alias: string
    image?: string | null
  }

  export type TreatmentTypeCreateOrConnectWithoutPostInput = {
    where: TreatmentTypeWhereUniqueInput
    create: XOR<TreatmentTypeCreateWithoutPostInput, TreatmentTypeUncheckedCreateWithoutPostInput>
  }

  export type UserCreateWithoutPostInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutPostInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutPostInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutPostInput, UserUncheckedCreateWithoutPostInput>
  }

  export type ReviewCreateWithoutPostInput = {
    id?: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    KoasProfile?: KoasProfileCreateNestedOneWithoutReviewInput
    user: UserCreateNestedOneWithoutReviewInput
  }

  export type ReviewUncheckedCreateWithoutPostInput = {
    id?: string
    pasienId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    koasId?: string | null
  }

  export type ReviewCreateOrConnectWithoutPostInput = {
    where: ReviewWhereUniqueInput
    create: XOR<ReviewCreateWithoutPostInput, ReviewUncheckedCreateWithoutPostInput>
  }

  export type ReviewCreateManyPostInputEnvelope = {
    data: ReviewCreateManyPostInput | ReviewCreateManyPostInput[]
    skipDuplicates?: boolean
  }

  export type ScheduleCreateWithoutPostInput = {
    id?: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentCreateNestedManyWithoutScheduleInput
    timeslot?: TimeslotCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleUncheckedCreateWithoutPostInput = {
    id?: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutScheduleInput
    timeslot?: TimeslotUncheckedCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleCreateOrConnectWithoutPostInput = {
    where: ScheduleWhereUniqueInput
    create: XOR<ScheduleCreateWithoutPostInput, ScheduleUncheckedCreateWithoutPostInput>
  }

  export type ScheduleCreateManyPostInputEnvelope = {
    data: ScheduleCreateManyPostInput | ScheduleCreateManyPostInput[]
    skipDuplicates?: boolean
  }

  export type LikeUpsertWithWhereUniqueWithoutPostInput = {
    where: LikeWhereUniqueInput
    update: XOR<LikeUpdateWithoutPostInput, LikeUncheckedUpdateWithoutPostInput>
    create: XOR<LikeCreateWithoutPostInput, LikeUncheckedCreateWithoutPostInput>
  }

  export type LikeUpdateWithWhereUniqueWithoutPostInput = {
    where: LikeWhereUniqueInput
    data: XOR<LikeUpdateWithoutPostInput, LikeUncheckedUpdateWithoutPostInput>
  }

  export type LikeUpdateManyWithWhereWithoutPostInput = {
    where: LikeScalarWhereInput
    data: XOR<LikeUpdateManyMutationInput, LikeUncheckedUpdateManyWithoutPostInput>
  }

  export type KoasProfileUpsertWithoutPostInput = {
    update: XOR<KoasProfileUpdateWithoutPostInput, KoasProfileUncheckedUpdateWithoutPostInput>
    create: XOR<KoasProfileCreateWithoutPostInput, KoasProfileUncheckedCreateWithoutPostInput>
    where?: KoasProfileWhereInput
  }

  export type KoasProfileUpdateToOneWithWhereWithoutPostInput = {
    where?: KoasProfileWhereInput
    data: XOR<KoasProfileUpdateWithoutPostInput, KoasProfileUncheckedUpdateWithoutPostInput>
  }

  export type KoasProfileUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUpdateManyWithoutKoasNestedInput
    University?: UniversityUpdateOneWithoutKoasProfileNestedInput
    user?: UserUpdateOneRequiredWithoutKoasProfileNestedInput
    Notification?: NotificationUpdateManyWithoutKoasProfileNestedInput
    Review?: ReviewUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutKoasNestedInput
    Notification?: NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput
  }

  export type TreatmentTypeUpsertWithoutPostInput = {
    update: XOR<TreatmentTypeUpdateWithoutPostInput, TreatmentTypeUncheckedUpdateWithoutPostInput>
    create: XOR<TreatmentTypeCreateWithoutPostInput, TreatmentTypeUncheckedCreateWithoutPostInput>
    where?: TreatmentTypeWhereInput
  }

  export type TreatmentTypeUpdateToOneWithWhereWithoutPostInput = {
    where?: TreatmentTypeWhereInput
    data: XOR<TreatmentTypeUpdateWithoutPostInput, TreatmentTypeUncheckedUpdateWithoutPostInput>
  }

  export type TreatmentTypeUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alias?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TreatmentTypeUncheckedUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    alias?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserUpsertWithoutPostInput = {
    update: XOR<UserUpdateWithoutPostInput, UserUncheckedUpdateWithoutPostInput>
    create: XOR<UserCreateWithoutPostInput, UserUncheckedCreateWithoutPostInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutPostInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutPostInput, UserUncheckedUpdateWithoutPostInput>
  }

  export type UserUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ReviewUpsertWithWhereUniqueWithoutPostInput = {
    where: ReviewWhereUniqueInput
    update: XOR<ReviewUpdateWithoutPostInput, ReviewUncheckedUpdateWithoutPostInput>
    create: XOR<ReviewCreateWithoutPostInput, ReviewUncheckedCreateWithoutPostInput>
  }

  export type ReviewUpdateWithWhereUniqueWithoutPostInput = {
    where: ReviewWhereUniqueInput
    data: XOR<ReviewUpdateWithoutPostInput, ReviewUncheckedUpdateWithoutPostInput>
  }

  export type ReviewUpdateManyWithWhereWithoutPostInput = {
    where: ReviewScalarWhereInput
    data: XOR<ReviewUpdateManyMutationInput, ReviewUncheckedUpdateManyWithoutPostInput>
  }

  export type ScheduleUpsertWithWhereUniqueWithoutPostInput = {
    where: ScheduleWhereUniqueInput
    update: XOR<ScheduleUpdateWithoutPostInput, ScheduleUncheckedUpdateWithoutPostInput>
    create: XOR<ScheduleCreateWithoutPostInput, ScheduleUncheckedCreateWithoutPostInput>
  }

  export type ScheduleUpdateWithWhereUniqueWithoutPostInput = {
    where: ScheduleWhereUniqueInput
    data: XOR<ScheduleUpdateWithoutPostInput, ScheduleUncheckedUpdateWithoutPostInput>
  }

  export type ScheduleUpdateManyWithWhereWithoutPostInput = {
    where: ScheduleScalarWhereInput
    data: XOR<ScheduleUpdateManyMutationInput, ScheduleUncheckedUpdateManyWithoutPostInput>
  }

  export type ScheduleScalarWhereInput = {
    AND?: ScheduleScalarWhereInput | ScheduleScalarWhereInput[]
    OR?: ScheduleScalarWhereInput[]
    NOT?: ScheduleScalarWhereInput | ScheduleScalarWhereInput[]
    id?: StringFilter<"Schedule"> | string
    postId?: StringFilter<"Schedule"> | string
    createdAt?: DateTimeFilter<"Schedule"> | Date | string
    dateEnd?: DateTimeFilter<"Schedule"> | Date | string
    dateStart?: DateTimeFilter<"Schedule"> | Date | string
    updateAt?: DateTimeFilter<"Schedule"> | Date | string
  }

  export type PostCreateWithoutLikesInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    koas: KoasProfileCreateNestedOneWithoutPostInput
    treatment: TreatmentTypeCreateNestedOneWithoutPostInput
    user: UserCreateNestedOneWithoutPostInput
    Review?: ReviewCreateNestedManyWithoutPostInput
    Schedule?: ScheduleCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateWithoutLikesInput = {
    id?: string
    userId: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    Review?: ReviewUncheckedCreateNestedManyWithoutPostInput
    Schedule?: ScheduleUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostCreateOrConnectWithoutLikesInput = {
    where: PostWhereUniqueInput
    create: XOR<PostCreateWithoutLikesInput, PostUncheckedCreateWithoutLikesInput>
  }

  export type UserCreateWithoutLikeInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutLikeInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutLikeInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutLikeInput, UserUncheckedCreateWithoutLikeInput>
  }

  export type PostUpsertWithoutLikesInput = {
    update: XOR<PostUpdateWithoutLikesInput, PostUncheckedUpdateWithoutLikesInput>
    create: XOR<PostCreateWithoutLikesInput, PostUncheckedCreateWithoutLikesInput>
    where?: PostWhereInput
  }

  export type PostUpdateToOneWithWhereWithoutLikesInput = {
    where?: PostWhereInput
    data: XOR<PostUpdateWithoutLikesInput, PostUncheckedUpdateWithoutLikesInput>
  }

  export type PostUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    koas?: KoasProfileUpdateOneRequiredWithoutPostNestedInput
    treatment?: TreatmentTypeUpdateOneRequiredWithoutPostNestedInput
    user?: UserUpdateOneRequiredWithoutPostNestedInput
    Review?: ReviewUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateWithoutLikesInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    Review?: ReviewUncheckedUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUncheckedUpdateManyWithoutPostNestedInput
  }

  export type UserUpsertWithoutLikeInput = {
    update: XOR<UserUpdateWithoutLikeInput, UserUncheckedUpdateWithoutLikeInput>
    create: XOR<UserCreateWithoutLikeInput, UserUncheckedCreateWithoutLikeInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutLikeInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutLikeInput, UserUncheckedUpdateWithoutLikeInput>
  }

  export type UserUpdateWithoutLikeInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutLikeInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type KoasProfileCreateWithoutNotificationInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentCreateNestedManyWithoutKoasInput
    University?: UniversityCreateNestedOneWithoutKoasProfileInput
    user: UserCreateNestedOneWithoutKoasProfileInput
    Post?: PostCreateNestedManyWithoutKoasInput
    Review?: ReviewCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUncheckedCreateWithoutNotificationInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutKoasInput
    Post?: PostUncheckedCreateNestedManyWithoutKoasInput
    Review?: ReviewUncheckedCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileCreateOrConnectWithoutNotificationInput = {
    where: KoasProfileWhereUniqueInput
    create: XOR<KoasProfileCreateWithoutNotificationInput, KoasProfileUncheckedCreateWithoutNotificationInput>
  }

  export type UserCreateWithoutSenderInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSenderInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSenderInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSenderInput, UserUncheckedCreateWithoutSenderInput>
  }

  export type UserCreateWithoutRecipientInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    Review?: ReviewCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutRecipientInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    Review?: ReviewUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutRecipientInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutRecipientInput, UserUncheckedCreateWithoutRecipientInput>
  }

  export type KoasProfileUpsertWithoutNotificationInput = {
    update: XOR<KoasProfileUpdateWithoutNotificationInput, KoasProfileUncheckedUpdateWithoutNotificationInput>
    create: XOR<KoasProfileCreateWithoutNotificationInput, KoasProfileUncheckedCreateWithoutNotificationInput>
    where?: KoasProfileWhereInput
  }

  export type KoasProfileUpdateToOneWithWhereWithoutNotificationInput = {
    where?: KoasProfileWhereInput
    data: XOR<KoasProfileUpdateWithoutNotificationInput, KoasProfileUncheckedUpdateWithoutNotificationInput>
  }

  export type KoasProfileUpdateWithoutNotificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUpdateManyWithoutKoasNestedInput
    University?: UniversityUpdateOneWithoutKoasProfileNestedInput
    user?: UserUpdateOneRequiredWithoutKoasProfileNestedInput
    Post?: PostUpdateManyWithoutKoasNestedInput
    Review?: ReviewUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateWithoutNotificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutKoasNestedInput
    Post?: PostUncheckedUpdateManyWithoutKoasNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput
  }

  export type UserUpsertWithoutSenderInput = {
    update: XOR<UserUpdateWithoutSenderInput, UserUncheckedUpdateWithoutSenderInput>
    create: XOR<UserCreateWithoutSenderInput, UserUncheckedCreateWithoutSenderInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSenderInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSenderInput, UserUncheckedUpdateWithoutSenderInput>
  }

  export type UserUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUpsertWithoutRecipientInput = {
    update: XOR<UserUpdateWithoutRecipientInput, UserUncheckedUpdateWithoutRecipientInput>
    create: XOR<UserCreateWithoutRecipientInput, UserUncheckedCreateWithoutRecipientInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutRecipientInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutRecipientInput, UserUncheckedUpdateWithoutRecipientInput>
  }

  export type UserUpdateWithoutRecipientInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    Review?: ReviewUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutRecipientInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type PostCreateWithoutTreatmentInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeCreateNestedManyWithoutPostInput
    koas: KoasProfileCreateNestedOneWithoutPostInput
    user: UserCreateNestedOneWithoutPostInput
    Review?: ReviewCreateNestedManyWithoutPostInput
    Schedule?: ScheduleCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateWithoutTreatmentInput = {
    id?: string
    userId: string
    koasId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedCreateNestedManyWithoutPostInput
    Review?: ReviewUncheckedCreateNestedManyWithoutPostInput
    Schedule?: ScheduleUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostCreateOrConnectWithoutTreatmentInput = {
    where: PostWhereUniqueInput
    create: XOR<PostCreateWithoutTreatmentInput, PostUncheckedCreateWithoutTreatmentInput>
  }

  export type PostCreateManyTreatmentInputEnvelope = {
    data: PostCreateManyTreatmentInput | PostCreateManyTreatmentInput[]
    skipDuplicates?: boolean
  }

  export type PostUpsertWithWhereUniqueWithoutTreatmentInput = {
    where: PostWhereUniqueInput
    update: XOR<PostUpdateWithoutTreatmentInput, PostUncheckedUpdateWithoutTreatmentInput>
    create: XOR<PostCreateWithoutTreatmentInput, PostUncheckedCreateWithoutTreatmentInput>
  }

  export type PostUpdateWithWhereUniqueWithoutTreatmentInput = {
    where: PostWhereUniqueInput
    data: XOR<PostUpdateWithoutTreatmentInput, PostUncheckedUpdateWithoutTreatmentInput>
  }

  export type PostUpdateManyWithWhereWithoutTreatmentInput = {
    where: PostScalarWhereInput
    data: XOR<PostUpdateManyMutationInput, PostUncheckedUpdateManyWithoutTreatmentInput>
  }

  export type AppointmentCreateWithoutScheduleInput = {
    id?: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
    koas: KoasProfileCreateNestedOneWithoutAppointmentInput
    pasien: PasienProfileCreateNestedOneWithoutAppointmentInput
    timeslot: TimeslotCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutScheduleInput = {
    id?: string
    pasienId: string
    koasId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentCreateOrConnectWithoutScheduleInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutScheduleInput, AppointmentUncheckedCreateWithoutScheduleInput>
  }

  export type AppointmentCreateManyScheduleInputEnvelope = {
    data: AppointmentCreateManyScheduleInput | AppointmentCreateManyScheduleInput[]
    skipDuplicates?: boolean
  }

  export type PostCreateWithoutScheduleInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeCreateNestedManyWithoutPostInput
    koas: KoasProfileCreateNestedOneWithoutPostInput
    treatment: TreatmentTypeCreateNestedOneWithoutPostInput
    user: UserCreateNestedOneWithoutPostInput
    Review?: ReviewCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateWithoutScheduleInput = {
    id?: string
    userId: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedCreateNestedManyWithoutPostInput
    Review?: ReviewUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostCreateOrConnectWithoutScheduleInput = {
    where: PostWhereUniqueInput
    create: XOR<PostCreateWithoutScheduleInput, PostUncheckedCreateWithoutScheduleInput>
  }

  export type TimeslotCreateWithoutScheduleInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    Appointment?: AppointmentCreateNestedManyWithoutTimeslotInput
  }

  export type TimeslotUncheckedCreateWithoutScheduleInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutTimeslotInput
  }

  export type TimeslotCreateOrConnectWithoutScheduleInput = {
    where: TimeslotWhereUniqueInput
    create: XOR<TimeslotCreateWithoutScheduleInput, TimeslotUncheckedCreateWithoutScheduleInput>
  }

  export type TimeslotCreateManyScheduleInputEnvelope = {
    data: TimeslotCreateManyScheduleInput | TimeslotCreateManyScheduleInput[]
    skipDuplicates?: boolean
  }

  export type AppointmentUpsertWithWhereUniqueWithoutScheduleInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutScheduleInput, AppointmentUncheckedUpdateWithoutScheduleInput>
    create: XOR<AppointmentCreateWithoutScheduleInput, AppointmentUncheckedCreateWithoutScheduleInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutScheduleInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutScheduleInput, AppointmentUncheckedUpdateWithoutScheduleInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutScheduleInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutScheduleInput>
  }

  export type PostUpsertWithoutScheduleInput = {
    update: XOR<PostUpdateWithoutScheduleInput, PostUncheckedUpdateWithoutScheduleInput>
    create: XOR<PostCreateWithoutScheduleInput, PostUncheckedCreateWithoutScheduleInput>
    where?: PostWhereInput
  }

  export type PostUpdateToOneWithWhereWithoutScheduleInput = {
    where?: PostWhereInput
    data: XOR<PostUpdateWithoutScheduleInput, PostUncheckedUpdateWithoutScheduleInput>
  }

  export type PostUpdateWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUpdateManyWithoutPostNestedInput
    koas?: KoasProfileUpdateOneRequiredWithoutPostNestedInput
    treatment?: TreatmentTypeUpdateOneRequiredWithoutPostNestedInput
    user?: UserUpdateOneRequiredWithoutPostNestedInput
    Review?: ReviewUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedUpdateManyWithoutPostNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutPostNestedInput
  }

  export type TimeslotUpsertWithWhereUniqueWithoutScheduleInput = {
    where: TimeslotWhereUniqueInput
    update: XOR<TimeslotUpdateWithoutScheduleInput, TimeslotUncheckedUpdateWithoutScheduleInput>
    create: XOR<TimeslotCreateWithoutScheduleInput, TimeslotUncheckedCreateWithoutScheduleInput>
  }

  export type TimeslotUpdateWithWhereUniqueWithoutScheduleInput = {
    where: TimeslotWhereUniqueInput
    data: XOR<TimeslotUpdateWithoutScheduleInput, TimeslotUncheckedUpdateWithoutScheduleInput>
  }

  export type TimeslotUpdateManyWithWhereWithoutScheduleInput = {
    where: TimeslotScalarWhereInput
    data: XOR<TimeslotUpdateManyMutationInput, TimeslotUncheckedUpdateManyWithoutScheduleInput>
  }

  export type TimeslotScalarWhereInput = {
    AND?: TimeslotScalarWhereInput | TimeslotScalarWhereInput[]
    OR?: TimeslotScalarWhereInput[]
    NOT?: TimeslotScalarWhereInput | TimeslotScalarWhereInput[]
    id?: StringFilter<"Timeslot"> | string
    startTime?: StringFilter<"Timeslot"> | string
    endTime?: StringFilter<"Timeslot"> | string
    maxParticipants?: IntNullableFilter<"Timeslot"> | number | null
    currentParticipants?: IntFilter<"Timeslot"> | number
    isAvailable?: BoolFilter<"Timeslot"> | boolean
    scheduleId?: StringFilter<"Timeslot"> | string
  }

  export type AppointmentCreateWithoutTimeslotInput = {
    id?: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
    koas: KoasProfileCreateNestedOneWithoutAppointmentInput
    pasien: PasienProfileCreateNestedOneWithoutAppointmentInput
    schedule: ScheduleCreateNestedOneWithoutAppointmentInput
  }

  export type AppointmentUncheckedCreateWithoutTimeslotInput = {
    id?: string
    pasienId: string
    koasId: string
    scheduleId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentCreateOrConnectWithoutTimeslotInput = {
    where: AppointmentWhereUniqueInput
    create: XOR<AppointmentCreateWithoutTimeslotInput, AppointmentUncheckedCreateWithoutTimeslotInput>
  }

  export type AppointmentCreateManyTimeslotInputEnvelope = {
    data: AppointmentCreateManyTimeslotInput | AppointmentCreateManyTimeslotInput[]
    skipDuplicates?: boolean
  }

  export type ScheduleCreateWithoutTimeslotInput = {
    id?: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentCreateNestedManyWithoutScheduleInput
    post: PostCreateNestedOneWithoutScheduleInput
  }

  export type ScheduleUncheckedCreateWithoutTimeslotInput = {
    id?: string
    postId: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleCreateOrConnectWithoutTimeslotInput = {
    where: ScheduleWhereUniqueInput
    create: XOR<ScheduleCreateWithoutTimeslotInput, ScheduleUncheckedCreateWithoutTimeslotInput>
  }

  export type AppointmentUpsertWithWhereUniqueWithoutTimeslotInput = {
    where: AppointmentWhereUniqueInput
    update: XOR<AppointmentUpdateWithoutTimeslotInput, AppointmentUncheckedUpdateWithoutTimeslotInput>
    create: XOR<AppointmentCreateWithoutTimeslotInput, AppointmentUncheckedCreateWithoutTimeslotInput>
  }

  export type AppointmentUpdateWithWhereUniqueWithoutTimeslotInput = {
    where: AppointmentWhereUniqueInput
    data: XOR<AppointmentUpdateWithoutTimeslotInput, AppointmentUncheckedUpdateWithoutTimeslotInput>
  }

  export type AppointmentUpdateManyWithWhereWithoutTimeslotInput = {
    where: AppointmentScalarWhereInput
    data: XOR<AppointmentUpdateManyMutationInput, AppointmentUncheckedUpdateManyWithoutTimeslotInput>
  }

  export type ScheduleUpsertWithoutTimeslotInput = {
    update: XOR<ScheduleUpdateWithoutTimeslotInput, ScheduleUncheckedUpdateWithoutTimeslotInput>
    create: XOR<ScheduleCreateWithoutTimeslotInput, ScheduleUncheckedCreateWithoutTimeslotInput>
    where?: ScheduleWhereInput
  }

  export type ScheduleUpdateToOneWithWhereWithoutTimeslotInput = {
    where?: ScheduleWhereInput
    data: XOR<ScheduleUpdateWithoutTimeslotInput, ScheduleUncheckedUpdateWithoutTimeslotInput>
  }

  export type ScheduleUpdateWithoutTimeslotInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUpdateManyWithoutScheduleNestedInput
    post?: PostUpdateOneRequiredWithoutScheduleNestedInput
  }

  export type ScheduleUncheckedUpdateWithoutTimeslotInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUncheckedUpdateManyWithoutScheduleNestedInput
  }

  export type KoasProfileCreateWithoutReviewInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    Appointment?: AppointmentCreateNestedManyWithoutKoasInput
    University?: UniversityCreateNestedOneWithoutKoasProfileInput
    user: UserCreateNestedOneWithoutKoasProfileInput
    Notification?: NotificationCreateNestedManyWithoutKoasProfileInput
    Post?: PostCreateNestedManyWithoutKoasInput
  }

  export type KoasProfileUncheckedCreateWithoutReviewInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
    Appointment?: AppointmentUncheckedCreateNestedManyWithoutKoasInput
    Notification?: NotificationUncheckedCreateNestedManyWithoutKoasProfileInput
    Post?: PostUncheckedCreateNestedManyWithoutKoasInput
  }

  export type KoasProfileCreateOrConnectWithoutReviewInput = {
    where: KoasProfileWhereUniqueInput
    create: XOR<KoasProfileCreateWithoutReviewInput, KoasProfileUncheckedCreateWithoutReviewInput>
  }

  export type PostCreateWithoutReviewInput = {
    id?: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeCreateNestedManyWithoutPostInput
    koas: KoasProfileCreateNestedOneWithoutPostInput
    treatment: TreatmentTypeCreateNestedOneWithoutPostInput
    user: UserCreateNestedOneWithoutPostInput
    Schedule?: ScheduleCreateNestedManyWithoutPostInput
  }

  export type PostUncheckedCreateWithoutReviewInput = {
    id?: string
    userId: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedCreateNestedManyWithoutPostInput
    Schedule?: ScheduleUncheckedCreateNestedManyWithoutPostInput
  }

  export type PostCreateOrConnectWithoutReviewInput = {
    where: PostWhereUniqueInput
    create: XOR<PostCreateWithoutReviewInput, PostUncheckedCreateWithoutReviewInput>
  }

  export type UserCreateWithoutReviewInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileCreateNestedOneWithoutUserInput
    Like?: LikeCreateNestedManyWithoutUserInput
    sender?: NotificationCreateNestedManyWithoutSenderInput
    recipient?: NotificationCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileCreateNestedOneWithoutUserInput
    Post?: PostCreateNestedManyWithoutUserInput
    sessions?: SessionCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutReviewInput = {
    id: string
    name?: string | null
    email?: string | null
    emailVerified?: Date | string | null
    password?: string | null
    phone?: string | null
    address?: string | null
    image?: string | null
    role?: $Enums.Role | null
    createdAt?: Date | string
    updateAt?: Date | string
    familyName?: string | null
    givenName?: string | null
    Account?: AccountUncheckedCreateNestedManyWithoutUserInput
    FasilitatorProfile?: FasilitatorProfileUncheckedCreateNestedOneWithoutUserInput
    KoasProfile?: KoasProfileUncheckedCreateNestedOneWithoutUserInput
    Like?: LikeUncheckedCreateNestedManyWithoutUserInput
    sender?: NotificationUncheckedCreateNestedManyWithoutSenderInput
    recipient?: NotificationUncheckedCreateNestedManyWithoutRecipientInput
    PasienProfile?: PasienProfileUncheckedCreateNestedOneWithoutUserInput
    Post?: PostUncheckedCreateNestedManyWithoutUserInput
    sessions?: SessionUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutReviewInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutReviewInput, UserUncheckedCreateWithoutReviewInput>
  }

  export type KoasProfileUpsertWithoutReviewInput = {
    update: XOR<KoasProfileUpdateWithoutReviewInput, KoasProfileUncheckedUpdateWithoutReviewInput>
    create: XOR<KoasProfileCreateWithoutReviewInput, KoasProfileUncheckedCreateWithoutReviewInput>
    where?: KoasProfileWhereInput
  }

  export type KoasProfileUpdateToOneWithWhereWithoutReviewInput = {
    where?: KoasProfileWhereInput
    data: XOR<KoasProfileUpdateWithoutReviewInput, KoasProfileUncheckedUpdateWithoutReviewInput>
  }

  export type KoasProfileUpdateWithoutReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUpdateManyWithoutKoasNestedInput
    University?: UniversityUpdateOneWithoutKoasProfileNestedInput
    user?: UserUpdateOneRequiredWithoutKoasProfileNestedInput
    Notification?: NotificationUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUpdateManyWithoutKoasNestedInput
  }

  export type KoasProfileUncheckedUpdateWithoutReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutKoasNestedInput
    Notification?: NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUncheckedUpdateManyWithoutKoasNestedInput
  }

  export type PostUpsertWithoutReviewInput = {
    update: XOR<PostUpdateWithoutReviewInput, PostUncheckedUpdateWithoutReviewInput>
    create: XOR<PostCreateWithoutReviewInput, PostUncheckedCreateWithoutReviewInput>
    where?: PostWhereInput
  }

  export type PostUpdateToOneWithWhereWithoutReviewInput = {
    where?: PostWhereInput
    data: XOR<PostUpdateWithoutReviewInput, PostUncheckedUpdateWithoutReviewInput>
  }

  export type PostUpdateWithoutReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUpdateManyWithoutPostNestedInput
    koas?: KoasProfileUpdateOneRequiredWithoutPostNestedInput
    treatment?: TreatmentTypeUpdateOneRequiredWithoutPostNestedInput
    user?: UserUpdateOneRequiredWithoutPostNestedInput
    Schedule?: ScheduleUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateWithoutReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUncheckedUpdateManyWithoutPostNestedInput
  }

  export type UserUpsertWithoutReviewInput = {
    update: XOR<UserUpdateWithoutReviewInput, UserUncheckedUpdateWithoutReviewInput>
    create: XOR<UserCreateWithoutReviewInput, UserUncheckedCreateWithoutReviewInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutReviewInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutReviewInput, UserUncheckedUpdateWithoutReviewInput>
  }

  export type UserUpdateWithoutReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUpdateOneWithoutUserNestedInput
    Like?: LikeUpdateManyWithoutUserNestedInput
    sender?: NotificationUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUpdateOneWithoutUserNestedInput
    Post?: PostUpdateManyWithoutUserNestedInput
    sessions?: SessionUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutReviewInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    email?: NullableStringFieldUpdateOperationsInput | string | null
    emailVerified?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    password?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    image?: NullableStringFieldUpdateOperationsInput | string | null
    role?: NullableEnumRoleFieldUpdateOperationsInput | $Enums.Role | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    familyName?: NullableStringFieldUpdateOperationsInput | string | null
    givenName?: NullableStringFieldUpdateOperationsInput | string | null
    Account?: AccountUncheckedUpdateManyWithoutUserNestedInput
    FasilitatorProfile?: FasilitatorProfileUncheckedUpdateOneWithoutUserNestedInput
    KoasProfile?: KoasProfileUncheckedUpdateOneWithoutUserNestedInput
    Like?: LikeUncheckedUpdateManyWithoutUserNestedInput
    sender?: NotificationUncheckedUpdateManyWithoutSenderNestedInput
    recipient?: NotificationUncheckedUpdateManyWithoutRecipientNestedInput
    PasienProfile?: PasienProfileUncheckedUpdateOneWithoutUserNestedInput
    Post?: PostUncheckedUpdateManyWithoutUserNestedInput
    sessions?: SessionUncheckedUpdateManyWithoutUserNestedInput
  }

  export type KoasProfileCreateWithoutAppointmentInput = {
    id?: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
    University?: UniversityCreateNestedOneWithoutKoasProfileInput
    user: UserCreateNestedOneWithoutKoasProfileInput
    Notification?: NotificationCreateNestedManyWithoutKoasProfileInput
    Post?: PostCreateNestedManyWithoutKoasInput
    Review?: ReviewCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileUncheckedCreateWithoutAppointmentInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    universityId?: string | null
    experience?: number | null
    Notification?: NotificationUncheckedCreateNestedManyWithoutKoasProfileInput
    Post?: PostUncheckedCreateNestedManyWithoutKoasInput
    Review?: ReviewUncheckedCreateNestedManyWithoutKoasProfileInput
  }

  export type KoasProfileCreateOrConnectWithoutAppointmentInput = {
    where: KoasProfileWhereUniqueInput
    create: XOR<KoasProfileCreateWithoutAppointmentInput, KoasProfileUncheckedCreateWithoutAppointmentInput>
  }

  export type PasienProfileCreateWithoutAppointmentInput = {
    id?: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
    user: UserCreateNestedOneWithoutPasienProfileInput
  }

  export type PasienProfileUncheckedCreateWithoutAppointmentInput = {
    id?: string
    userId: string
    age?: string | null
    gender?: string | null
    bio?: string | null
    createdAt?: Date | string
    updateAt?: Date | string
  }

  export type PasienProfileCreateOrConnectWithoutAppointmentInput = {
    where: PasienProfileWhereUniqueInput
    create: XOR<PasienProfileCreateWithoutAppointmentInput, PasienProfileUncheckedCreateWithoutAppointmentInput>
  }

  export type ScheduleCreateWithoutAppointmentInput = {
    id?: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    post: PostCreateNestedOneWithoutScheduleInput
    timeslot?: TimeslotCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleUncheckedCreateWithoutAppointmentInput = {
    id?: string
    postId: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
    timeslot?: TimeslotUncheckedCreateNestedManyWithoutScheduleInput
  }

  export type ScheduleCreateOrConnectWithoutAppointmentInput = {
    where: ScheduleWhereUniqueInput
    create: XOR<ScheduleCreateWithoutAppointmentInput, ScheduleUncheckedCreateWithoutAppointmentInput>
  }

  export type TimeslotCreateWithoutAppointmentInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    schedule: ScheduleCreateNestedOneWithoutTimeslotInput
  }

  export type TimeslotUncheckedCreateWithoutAppointmentInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
    scheduleId: string
  }

  export type TimeslotCreateOrConnectWithoutAppointmentInput = {
    where: TimeslotWhereUniqueInput
    create: XOR<TimeslotCreateWithoutAppointmentInput, TimeslotUncheckedCreateWithoutAppointmentInput>
  }

  export type KoasProfileUpsertWithoutAppointmentInput = {
    update: XOR<KoasProfileUpdateWithoutAppointmentInput, KoasProfileUncheckedUpdateWithoutAppointmentInput>
    create: XOR<KoasProfileCreateWithoutAppointmentInput, KoasProfileUncheckedCreateWithoutAppointmentInput>
    where?: KoasProfileWhereInput
  }

  export type KoasProfileUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: KoasProfileWhereInput
    data: XOR<KoasProfileUpdateWithoutAppointmentInput, KoasProfileUncheckedUpdateWithoutAppointmentInput>
  }

  export type KoasProfileUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    University?: UniversityUpdateOneWithoutKoasProfileNestedInput
    user?: UserUpdateOneRequiredWithoutKoasProfileNestedInput
    Notification?: NotificationUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUpdateManyWithoutKoasNestedInput
    Review?: ReviewUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    universityId?: NullableStringFieldUpdateOperationsInput | string | null
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Notification?: NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUncheckedUpdateManyWithoutKoasNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput
  }

  export type PasienProfileUpsertWithoutAppointmentInput = {
    update: XOR<PasienProfileUpdateWithoutAppointmentInput, PasienProfileUncheckedUpdateWithoutAppointmentInput>
    create: XOR<PasienProfileCreateWithoutAppointmentInput, PasienProfileUncheckedCreateWithoutAppointmentInput>
    where?: PasienProfileWhereInput
  }

  export type PasienProfileUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: PasienProfileWhereInput
    data: XOR<PasienProfileUpdateWithoutAppointmentInput, PasienProfileUncheckedUpdateWithoutAppointmentInput>
  }

  export type PasienProfileUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutPasienProfileNestedInput
  }

  export type PasienProfileUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ScheduleUpsertWithoutAppointmentInput = {
    update: XOR<ScheduleUpdateWithoutAppointmentInput, ScheduleUncheckedUpdateWithoutAppointmentInput>
    create: XOR<ScheduleCreateWithoutAppointmentInput, ScheduleUncheckedCreateWithoutAppointmentInput>
    where?: ScheduleWhereInput
  }

  export type ScheduleUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: ScheduleWhereInput
    data: XOR<ScheduleUpdateWithoutAppointmentInput, ScheduleUncheckedUpdateWithoutAppointmentInput>
  }

  export type ScheduleUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    post?: PostUpdateOneRequiredWithoutScheduleNestedInput
    timeslot?: TimeslotUpdateManyWithoutScheduleNestedInput
  }

  export type ScheduleUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    timeslot?: TimeslotUncheckedUpdateManyWithoutScheduleNestedInput
  }

  export type TimeslotUpsertWithoutAppointmentInput = {
    update: XOR<TimeslotUpdateWithoutAppointmentInput, TimeslotUncheckedUpdateWithoutAppointmentInput>
    create: XOR<TimeslotCreateWithoutAppointmentInput, TimeslotUncheckedCreateWithoutAppointmentInput>
    where?: TimeslotWhereInput
  }

  export type TimeslotUpdateToOneWithWhereWithoutAppointmentInput = {
    where?: TimeslotWhereInput
    data: XOR<TimeslotUpdateWithoutAppointmentInput, TimeslotUncheckedUpdateWithoutAppointmentInput>
  }

  export type TimeslotUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    schedule?: ScheduleUpdateOneRequiredWithoutTimeslotNestedInput
  }

  export type TimeslotUncheckedUpdateWithoutAppointmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    scheduleId?: StringFieldUpdateOperationsInput | string
  }

  export type AccountCreateManyUserInput = {
    type?: string | null
    provider: string
    scope?: string | null
    access_token?: string | null
    expires_at?: number | null
    id_token?: string | null
    providerAccountId: string
    refresh_token?: string | null
    token_type?: string | null
    id?: string
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LikeCreateManyUserInput = {
    id?: string
    postId: string
    createdAt?: Date | string
  }

  export type NotificationCreateManySenderInput = {
    id?: string
    message: string
    createdAt?: Date | string
    koasId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    userId?: string | null
  }

  export type NotificationCreateManyRecipientInput = {
    id?: string
    message: string
    createdAt?: Date | string
    koasId?: string | null
    senderId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
  }

  export type PostCreateManyUserInput = {
    id?: string
    koasId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type ReviewCreateManyUserInput = {
    id?: string
    postId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    koasId?: string | null
  }

  export type SessionCreateManyUserInput = {
    id?: string
    expires: Date | string
    sessionToken: string
    accessToken?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AccountUpdateWithoutUserInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateWithoutUserInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyWithoutUserInput = {
    type?: NullableStringFieldUpdateOperationsInput | string | null
    provider?: StringFieldUpdateOperationsInput | string
    scope?: NullableStringFieldUpdateOperationsInput | string | null
    access_token?: NullableStringFieldUpdateOperationsInput | string | null
    expires_at?: NullableIntFieldUpdateOperationsInput | number | null
    id_token?: NullableStringFieldUpdateOperationsInput | string | null
    providerAccountId?: StringFieldUpdateOperationsInput | string
    refresh_token?: NullableStringFieldUpdateOperationsInput | string | null
    token_type?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LikeUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Post?: PostUpdateOneRequiredWithoutLikesNestedInput
  }

  export type LikeUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LikeUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasProfile?: KoasProfileUpdateOneWithoutNotificationNestedInput
    recipient?: UserUpdateOneWithoutRecipientNestedInput
  }

  export type NotificationUncheckedUpdateWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type NotificationUncheckedUpdateManyWithoutSenderInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type NotificationUpdateWithoutRecipientInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasProfile?: KoasProfileUpdateOneWithoutNotificationNestedInput
    sender?: UserUpdateOneWithoutSenderNestedInput
  }

  export type NotificationUncheckedUpdateWithoutRecipientInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
    senderId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUncheckedUpdateManyWithoutRecipientInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
    senderId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PostUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUpdateManyWithoutPostNestedInput
    koas?: KoasProfileUpdateOneRequiredWithoutPostNestedInput
    treatment?: TreatmentTypeUpdateOneRequiredWithoutPostNestedInput
    Review?: ReviewUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedUpdateManyWithoutPostNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUncheckedUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type ReviewUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    KoasProfile?: KoasProfileUpdateOneWithoutReviewNestedInput
    post?: PostUpdateOneRequiredWithoutReviewNestedInput
  }

  export type ReviewUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ReviewUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SessionUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SessionUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    expires?: DateTimeFieldUpdateOperationsInput | Date | string
    sessionToken?: StringFieldUpdateOperationsInput | string
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateManyKoasInput = {
    id?: string
    pasienId: string
    scheduleId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type NotificationCreateManyKoasProfileInput = {
    id?: string
    message: string
    createdAt?: Date | string
    senderId?: string | null
    status?: $Enums.StatusNotification
    title: string
    updatedAt?: Date | string
    userId?: string | null
  }

  export type PostCreateManyKoasInput = {
    id?: string
    userId: string
    treatmentId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type ReviewCreateManyKoasProfileInput = {
    id?: string
    postId: string
    pasienId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
  }

  export type AppointmentUpdateWithoutKoasInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    pasien?: PasienProfileUpdateOneRequiredWithoutAppointmentNestedInput
    schedule?: ScheduleUpdateOneRequiredWithoutAppointmentNestedInput
    timeslot?: TimeslotUpdateOneRequiredWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutKoasInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUncheckedUpdateManyWithoutKoasInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sender?: UserUpdateOneWithoutSenderNestedInput
    recipient?: UserUpdateOneWithoutRecipientNestedInput
  }

  export type NotificationUncheckedUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    senderId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type NotificationUncheckedUpdateManyWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    senderId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusNotificationFieldUpdateOperationsInput | $Enums.StatusNotification
    title?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type PostUpdateWithoutKoasInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUpdateManyWithoutPostNestedInput
    treatment?: TreatmentTypeUpdateOneRequiredWithoutPostNestedInput
    user?: UserUpdateOneRequiredWithoutPostNestedInput
    Review?: ReviewUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateWithoutKoasInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedUpdateManyWithoutPostNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUncheckedUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateManyWithoutKoasInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    treatmentId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type ReviewUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    post?: PostUpdateOneRequiredWithoutReviewNestedInput
    user?: UserUpdateOneRequiredWithoutReviewNestedInput
  }

  export type ReviewUncheckedUpdateWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ReviewUncheckedUpdateManyWithoutKoasProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    postId?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentCreateManyPasienInput = {
    id?: string
    koasId: string
    scheduleId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentUpdateWithoutPasienInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koas?: KoasProfileUpdateOneRequiredWithoutAppointmentNestedInput
    schedule?: ScheduleUpdateOneRequiredWithoutAppointmentNestedInput
    timeslot?: TimeslotUpdateOneRequiredWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutPasienInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUncheckedUpdateManyWithoutPasienInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type KoasProfileCreateManyUniversityInput = {
    id?: string
    userId: string
    koasNumber?: string | null
    age?: string | null
    gender?: string | null
    departement?: string | null
    university?: string | null
    bio?: string | null
    whatsappLink?: string | null
    status?: $Enums.StatusKoas
    createdAt?: Date | string
    updateAt?: Date | string
    experience?: number | null
  }

  export type KoasProfileUpdateWithoutUniversityInput = {
    id?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUpdateManyWithoutKoasNestedInput
    user?: UserUpdateOneRequiredWithoutKoasProfileNestedInput
    Notification?: NotificationUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUpdateManyWithoutKoasNestedInput
    Review?: ReviewUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateWithoutUniversityInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
    Appointment?: AppointmentUncheckedUpdateManyWithoutKoasNestedInput
    Notification?: NotificationUncheckedUpdateManyWithoutKoasProfileNestedInput
    Post?: PostUncheckedUpdateManyWithoutKoasNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutKoasProfileNestedInput
  }

  export type KoasProfileUncheckedUpdateManyWithoutUniversityInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasNumber?: NullableStringFieldUpdateOperationsInput | string | null
    age?: NullableStringFieldUpdateOperationsInput | string | null
    gender?: NullableStringFieldUpdateOperationsInput | string | null
    departement?: NullableStringFieldUpdateOperationsInput | string | null
    university?: NullableStringFieldUpdateOperationsInput | string | null
    bio?: NullableStringFieldUpdateOperationsInput | string | null
    whatsappLink?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumStatusKoasFieldUpdateOperationsInput | $Enums.StatusKoas
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    experience?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type LikeCreateManyPostInput = {
    id?: string
    userId: string
    createdAt?: Date | string
  }

  export type ReviewCreateManyPostInput = {
    id?: string
    pasienId: string
    rating?: Decimal | DecimalJsLike | number | string
    comment?: string | null
    createdAt?: Date | string
    koasId?: string | null
  }

  export type ScheduleCreateManyPostInput = {
    id?: string
    createdAt?: Date | string
    dateEnd: Date | string
    dateStart: Date | string
    updateAt?: Date | string
  }

  export type LikeUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutLikeNestedInput
  }

  export type LikeUncheckedUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LikeUncheckedUpdateManyWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ReviewUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    KoasProfile?: KoasProfileUpdateOneWithoutReviewNestedInput
    user?: UserUpdateOneRequiredWithoutReviewNestedInput
  }

  export type ReviewUncheckedUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ReviewUncheckedUpdateManyWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    rating?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koasId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ScheduleUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUpdateManyWithoutScheduleNestedInput
    timeslot?: TimeslotUpdateManyWithoutScheduleNestedInput
  }

  export type ScheduleUncheckedUpdateWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    Appointment?: AppointmentUncheckedUpdateManyWithoutScheduleNestedInput
    timeslot?: TimeslotUncheckedUpdateManyWithoutScheduleNestedInput
  }

  export type ScheduleUncheckedUpdateManyWithoutPostInput = {
    id?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dateEnd?: DateTimeFieldUpdateOperationsInput | Date | string
    dateStart?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PostCreateManyTreatmentInput = {
    id?: string
    userId: string
    koasId: string
    title: string
    desc: string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: $Enums.StatusPost
    published?: boolean
    createdAt?: Date | string
    updateAt?: Date | string
    requiredParticipant?: number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type PostUpdateWithoutTreatmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUpdateManyWithoutPostNestedInput
    koas?: KoasProfileUpdateOneRequiredWithoutPostNestedInput
    user?: UserUpdateOneRequiredWithoutPostNestedInput
    Review?: ReviewUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateWithoutTreatmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
    likes?: LikeUncheckedUpdateManyWithoutPostNestedInput
    Review?: ReviewUncheckedUpdateManyWithoutPostNestedInput
    Schedule?: ScheduleUncheckedUpdateManyWithoutPostNestedInput
  }

  export type PostUncheckedUpdateManyWithoutTreatmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    desc?: StringFieldUpdateOperationsInput | string
    patientRequirement?: NullableJsonNullValueInput | InputJsonValue
    status?: EnumStatusPostFieldUpdateOperationsInput | $Enums.StatusPost
    published?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updateAt?: DateTimeFieldUpdateOperationsInput | Date | string
    requiredParticipant?: IntFieldUpdateOperationsInput | number
    images?: NullableJsonNullValueInput | InputJsonValue
  }

  export type AppointmentCreateManyScheduleInput = {
    id?: string
    pasienId: string
    koasId: string
    timeslotId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type TimeslotCreateManyScheduleInput = {
    id?: string
    startTime: string
    endTime: string
    maxParticipants?: number | null
    currentParticipants?: number
    isAvailable?: boolean
  }

  export type AppointmentUpdateWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koas?: KoasProfileUpdateOneRequiredWithoutAppointmentNestedInput
    pasien?: PasienProfileUpdateOneRequiredWithoutAppointmentNestedInput
    timeslot?: TimeslotUpdateOneRequiredWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUncheckedUpdateManyWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    timeslotId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TimeslotUpdateWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    Appointment?: AppointmentUpdateManyWithoutTimeslotNestedInput
  }

  export type TimeslotUncheckedUpdateWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
    Appointment?: AppointmentUncheckedUpdateManyWithoutTimeslotNestedInput
  }

  export type TimeslotUncheckedUpdateManyWithoutScheduleInput = {
    id?: StringFieldUpdateOperationsInput | string
    startTime?: StringFieldUpdateOperationsInput | string
    endTime?: StringFieldUpdateOperationsInput | string
    maxParticipants?: NullableIntFieldUpdateOperationsInput | number | null
    currentParticipants?: IntFieldUpdateOperationsInput | number
    isAvailable?: BoolFieldUpdateOperationsInput | boolean
  }

  export type AppointmentCreateManyTimeslotInput = {
    id?: string
    pasienId: string
    koasId: string
    scheduleId: string
    date: string
    status?: $Enums.StatusAppointment
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AppointmentUpdateWithoutTimeslotInput = {
    id?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    koas?: KoasProfileUpdateOneRequiredWithoutAppointmentNestedInput
    pasien?: PasienProfileUpdateOneRequiredWithoutAppointmentNestedInput
    schedule?: ScheduleUpdateOneRequiredWithoutAppointmentNestedInput
  }

  export type AppointmentUncheckedUpdateWithoutTimeslotInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AppointmentUncheckedUpdateManyWithoutTimeslotInput = {
    id?: StringFieldUpdateOperationsInput | string
    pasienId?: StringFieldUpdateOperationsInput | string
    koasId?: StringFieldUpdateOperationsInput | string
    scheduleId?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    status?: EnumStatusAppointmentFieldUpdateOperationsInput | $Enums.StatusAppointment
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}